fix(hunter): match documented Discover response and coerce numeric employees

Author: waleedlatif1

apps/sim/blocks/blocks/hunter.ts

@@ -373,7 +373,7 @@ Return ONLY the search query text - no explanations.`,
     results: {
       type: 'array',
       description:
-        'Companies matching the search (name, domain, logo, linkedin_url, company_type, industry, size, location, founded_year, crunchbase_url)',
+        'Companies matching the search (domain, organization, personal_emails, generic_emails, total_emails)',
     },
     // Companies Find (flattened)
     name: { type: 'string', description: 'Company name (companies-find, discover)' },

apps/sim/tools/hunter/companies_find.ts

@@ -48,7 +48,9 @@ export const companiesFindTool: ToolConfig<HunterEnrichmentParams, HunterEnrichm
         description: c.description ?? '',
         industry: c.category?.industry ?? '',
         sector: c.category?.sector ?? '',
-        size: c.metrics?.employees ?? '',
+        size:
+          c.metrics?.employeesRange ??
+          (c.metrics?.employees != null ? String(c.metrics.employees) : ''),
         founded_year: c.foundedYear ?? null,
         location: c.location ?? '',
         country: c.geo?.country ?? '',

apps/sim/tools/hunter/discover.ts

@@ -75,7 +75,7 @@ export const discoverTool: ToolConfig<HunterDiscoverParams, HunterDiscoverRespon
 
       if (params.query) body.query = params.query
       if (params.domain) body.organization = { domain: [params.domain] }
-      if (params.headcount) body.headcount = { include: [params.headcount] }
+      if (params.headcount) body.headcount = [params.headcount]
       if (params.company_type) body.company_type = { include: [params.company_type] }
       if (params.technology) {
         body.technology = {
@@ -89,38 +89,22 @@ export const discoverTool: ToolConfig<HunterDiscoverParams, HunterDiscoverRespon
 
   transformResponse: async (response: Response) => {
     const data = await response.json()
+    const companies: Array<{
+      domain?: string
+      organization?: string
+      emails_count?: { personal?: number; generic?: number; total?: number }
+    }> = Array.isArray(data?.data) ? data.data : []
 
     return {
       success: true,
       output: {
-        results:
-          data.companies?.map(
-            (company: {
-              name?: string
-              domain?: string
-              logo?: string | null
-              linkedin_url?: string | null
-              company_type?: string | null
-              meta?: {
-                crunchbase_url?: string | null
-                founded_year?: number | null
-                location?: string | null
-                industry?: string | null
-                size?: string | null
-              }
-            }) => ({
-              name: company.name ?? '',
-              domain: company.domain ?? '',
-              logo: company.logo ?? null,
-              linkedin_url: company.linkedin_url ?? null,
-              company_type: company.company_type ?? null,
-              industry: company.meta?.industry ?? null,
-              size: company.meta?.size ?? null,
-              location: company.meta?.location ?? null,
-              founded_year: company.meta?.founded_year ?? null,
-              crunchbase_url: company.meta?.crunchbase_url ?? null,
-            })
-          ) ?? [],
+        results: companies.map((c) => ({
+          domain: c.domain ?? '',
+          organization: c.organization ?? '',
+          personal_emails: c.emails_count?.personal ?? 0,
+          generic_emails: c.emails_count?.generic ?? 0,
+          total_emails: c.emails_count?.total ?? 0,
+        })),
       },
     }
   },

apps/sim/tools/hunter/hunter.test.ts

@@ -137,60 +137,60 @@ describe('hunter email_finder', () => {
 describe('hunter discover', () => {
   const transform = discoverTool.transformResponse!
 
-  it('maps companies array (not data.data)', async () => {
+  it('maps documented data array shape', async () => {
     const result = await transform(
       respond({
-        companies: [
+        data: [
           {
-            name: 'Stripe',
-            domain: 'stripe.com',
-            logo: 'https://logo.png',
-            linkedin_url: 'https://linkedin.com/company/stripe',
-            company_type: 'Privately Held',
-            meta: {
-              industry: 'Fintech',
-              size: '1000+',
-              location: 'San Francisco, CA',
-              founded_year: 2010,
-              crunchbase_url: 'https://crunchbase.com/org/stripe',
-            },
+            domain: 'hunter.io',
+            organization: 'Hunter',
+            emails_count: { personal: 23, generic: 5, total: 28 },
           },
         ],
       })
     )
 
-    expect(result.output.results).toHaveLength(1)
-    expect(result.output.results[0]).toEqual({
-      name: 'Stripe',
-      domain: 'stripe.com',
-      logo: 'https://logo.png',
-      linkedin_url: 'https://linkedin.com/company/stripe',
-      company_type: 'Privately Held',
-      industry: 'Fintech',
-      size: '1000+',
-      location: 'San Francisco, CA',
-      founded_year: 2010,
-      crunchbase_url: 'https://crunchbase.com/org/stripe',
-    })
+    expect(result.output.results).toEqual([
+      {
+        domain: 'hunter.io',
+        organization: 'Hunter',
+        personal_emails: 23,
+        generic_emails: 5,
+        total_emails: 28,
+      },
+    ])
   })
 
-  it('returns empty array when companies is missing', async () => {
+  it('returns empty array when data is missing', async () => {
     const result = await transform(respond({}))
     expect(result.output.results).toEqual([])
   })
 
+  it('falls back to zero counts when emails_count is missing', async () => {
+    const result = await transform(
+      respond({ data: [{ domain: 'acme.com', organization: 'Acme' }] })
+    )
+    expect(result.output.results[0]).toEqual({
+      domain: 'acme.com',
+      organization: 'Acme',
+      personal_emails: 0,
+      generic_emails: 0,
+      total_emails: 0,
+    })
+  })
+
   it('throws when no search params provided', () => {
     const buildUrl = discoverTool.request.url as (p: Record<string, unknown>) => string
     expect(() => buildUrl({ apiKey: 'k' })).toThrow(/At least one search parameter/)
   })
 
-  it('wraps headcount in include array', () => {
+  it('builds body per docs (headcount as plain array, technology wrapped)', () => {
     const buildBody = discoverTool.request.body as (
       p: Record<string, unknown>
     ) => Record<string, unknown>
     const body = buildBody({ apiKey: 'k', headcount: '11-50', technology: 'react' })
     expect(body).toEqual({
-      headcount: { include: ['11-50'] },
+      headcount: ['11-50'],
       technology: { include: ['react'] },
     })
   })
@@ -243,6 +243,16 @@ describe('hunter companies_find', () => {
     })
   })
 
+  it('prefers employeesRange and coerces numeric employees', async () => {
+    const rangeResult = await transform(
+      respond({ data: { metrics: { employees: 5432, employeesRange: '1001-5000' } } })
+    )
+    expect(rangeResult.output.size).toBe('1001-5000')
+
+    const numericResult = await transform(respond({ data: { metrics: { employees: 5432 } } }))
+    expect(numericResult.output.size).toBe('5432')
+  })
+
   it('survives missing nested objects', async () => {
     const result = await transform(respond({ data: {} }))
     expect(result.output).toMatchObject({

apps/sim/tools/hunter/types.ts

@@ -153,35 +153,16 @@ export const SENIORITY_OUTPUT: OutputProperty = {
 }
 
 /**
- * Output definition for discover result company objects
+ * Output definition for discover result company objects.
+ * Hunter Discover returns minimal info per company — use Domain Search or
+ * Company Enrichment for richer data on a specific result.
  */
 export const DISCOVER_RESULT_OUTPUT_PROPERTIES = {
-  name: { type: 'string', description: 'Company name' },
   domain: { type: 'string', description: 'Company domain' },
-  logo: { type: 'string', description: 'URL of the company logo', optional: true },
-  linkedin_url: {
-    type: 'string',
-    description: 'LinkedIn profile URL of the company',
-    optional: true,
-  },
-  company_type: {
-    type: 'string',
-    description: 'Company type (e.g., privately held, public company)',
-    optional: true,
-  },
-  industry: { type: 'string', description: 'Industry of the company', optional: true },
-  size: { type: 'string', description: 'Headcount range of the company', optional: true },
-  location: { type: 'string', description: 'Headquarters location', optional: true },
-  founded_year: {
-    type: 'number',
-    description: 'Year the company was founded',
-    optional: true,
-  },
-  crunchbase_url: {
-    type: 'string',
-    description: 'Crunchbase URL of the company',
-    optional: true,
-  },
+  organization: { type: 'string', description: 'Organization name' },
+  personal_emails: { type: 'number', description: 'Count of personal emails' },
+  generic_emails: { type: 'number', description: 'Count of generic (role-based) emails' },
+  total_emails: { type: 'number', description: 'Total emails found for the company' },
 } as const satisfies Record<string, OutputProperty>
 
 /**
@@ -211,16 +192,11 @@ export interface HunterDiscoverParams extends HunterBaseParams {
 }
 
 export interface HunterDiscoverResult {
-  name: string
   domain: string
-  logo: string | null
-  linkedin_url: string | null
-  company_type: string | null
-  industry: string | null
-  size: string | null
-  location: string | null
-  founded_year: number | null
-  crunchbase_url: string | null
+  organization: string
+  personal_emails: number
+  generic_emails: number
+  total_emails: number
 }
 
 export interface HunterDiscoverResponse extends ToolResponse {