companyBulkLookup

Instructions

Implementation Reference

• src/tools/companyLookup.ts:19-87 (handler)

  Main handler function for the companyBulkLookup tool. Validates input, calls Lusha API POST /v2/company, and returns company data.

  export const companyBulkLookupHandler = async (params: CompanyBulkLookupParams): Promise<ToolResponse> => {
    const requestId = generateRequestId();
    
    const context: ErrorContext = {
      requestId,
      toolName: 'companyBulkLookup',
      operation: 'bulk_company_lookup',
      inputParams: { companyCount: params.companies?.length, metadata: params.metadata }
    };
  
    try {
      logger.info('Starting bulk company lookup request', { 
        requestId,
        toolName: 'companyBulkLookup',
        companyCount: params.companies?.length,
        inputParams: params 
      });
      
      const validatedParams = companyBulkLookupSchema.parse(params);
      logger.debug('Input validation passed', { requestId, toolName: 'companyBulkLookup' });
      
      const client = createLushaClient();
      context.apiEndpoint = '/v2/company';
      
      logger.debug('Making bulk company API request', { 
        requestId,
        toolName: 'companyBulkLookup',
        companyCount: validatedParams.companies.length,
        endpoint: context.apiEndpoint
      });
  
      const companiesForApi = validatedParams.companies.map(company => ({
        id: company.id,
        name: company.name,
        domain: company.domain,
        fqdn: company.fqdn,
        companyId: company.companyId
      }));
      
      const response = await client.post('/v2/company', {
        companies: companiesForApi
      });
      
      logger.info('Bulk company lookup completed successfully', { 
        requestId,
        toolName: 'companyBulkLookup',
        responseStatus: response.status,
        processedCompanies: Object.keys(response.data || {}).length
      });
      
      return {
        type: "success",
        data: {
          ...response.data,
          requestId,
          timestamp: new Date().toISOString()
        }
      };
      
    } catch (error) {
      logger.error('Bulk company lookup failed', { 
        error: (error as Error).message,
        stack: (error as Error).stack,
        requestId,
        toolName: 'companyBulkLookup'
      });
      return handleApiError(error, context);
    }
  }; 

• src/schemas.ts:111-133 (schema)

  Zod schema for companyBulkLookup: expects an array of 1-100 companies, each requiring at least one of name, domain, fqdn, or companyId, with optional metadata.filterBy.

  export const companyBulkLookupSchema = z.object({
    companies: z.array(z.object({
      id: z.string().min(1, "Company ID is required").describe("Unique ID for the company in the request"),
      name: z.string().optional().describe("Company name"),
      domain: z.string().optional().describe("Company domain"),
      fqdn: z.string().optional().describe("Fully qualified domain name of the company"),
      companyId: z.string().optional().describe("A unique identifier for a Lusha company")
    }).refine((company) => {
      const hasName = company.name && company.name.trim();
      const hasDomain = company.domain && company.domain.trim();
      const hasFqdn = company.fqdn && company.fqdn.trim();
      const hasCompanyId = company.companyId && company.companyId.trim();
  
      return hasName || hasDomain || hasFqdn || hasCompanyId;
    }, {
      message: "Each company must have at least one of: name, domain, fqdn, or companyId"
    }))
    .min(1, "Companies array cannot be empty")
    .max(100, "Companies array cannot exceed 100 items"),
    metadata: z.object({
      filterBy: z.string().optional()
    }).optional()
  });

• src/schemas.ts:217-217 (schema)

  TypeScript type derived from companyBulkLookupSchema for type safety.

  export type CompanyBulkLookupParams = z.infer<typeof companyBulkLookupSchema>;

• src/config/tools.ts:50-61 (registration)

  Registration of companyBulkLookup tool with its name, description, schema, and handler.

  {
    name: "companyBulkLookup",
    description: `Look up multiple or single companies information from Lusha API.
        REQUIREMENTS: Each company must provide at least one of:
        1. Company name,
        2. Company domain,
        3. Fully qualified domain name (fqdn), or
        4. Lusha companyId.
        Each company must have a unique 'id' field for identification in the response.`,
    schema: companyBulkLookupSchema,
    handler: companyBulkLookupHandler
  },