dhisana 0.0.1.dev277__tar.gz → 0.0.1.dev279__tar.gz

{dhisana-0.0.1.dev277 → dhisana-0.0.1.dev279}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev277
+Version: 0.0.1.dev279
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev277 → dhisana-0.0.1.dev279}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='dhisana',  
-    version='0.0.1-dev277',
+    version='0.0.1-dev279',
     description='A Python SDK for Dhisana AI Platform',
     author='Admin',
     author_email='contact@dhisana.ai',

{dhisana-0.0.1.dev277 → dhisana-0.0.1.dev279}/src/dhisana/utils/apollo_tools.py

@@ -1345,7 +1345,14 @@ def fill_in_company_properties(company_data: dict) -> dict:
     if annual_revenue is None:
         annual_revenue = _parse_compact_number(company_data.get("organization_revenue_printed"))
 
-    company_size = company_data.get("estimated_num_employees")
+    # Try multiple fields for company size/employee count
+    company_size = (
+        company_data.get("estimated_num_employees")
+        or company_data.get("num_employees")
+        or company_data.get("employee_count")
+        or company_data.get("employees_count")
+        or company_data.get("headcount")
+    )
     if company_size is not None:
         try:
             company_size = int(company_size)
@@ -1373,10 +1380,14 @@ def fill_in_company_properties(company_data: dict) -> dict:
         or company_data.get("sanitized_phone")
     )
 
+    # Try multiple fields for industry
     industry = company_data.get("industry")
     if not industry and isinstance(company_data.get("industries"), list):
         industries = [str(x).strip() for x in company_data["industries"] if str(x).strip()]
         industry = industries[0] if industries else None
+    # Some Apollo responses have industry_tag_id but not industry name
+    if not industry and company_data.get("industry_tag_id"):
+        industry = company_data.get("industry_tag_id")
 
     billing_street = (
         company_data.get("street_address")
@@ -1385,19 +1396,42 @@ def fill_in_company_properties(company_data: dict) -> dict:
         or company_data.get("raw_address")
     )
 
+    # Determine ownership from publicly traded info
+    ownership = company_data.get("ownership")
+    if not ownership:
+        if company_data.get("publicly_traded_symbol") or company_data.get("publicly_traded_exchange"):
+            ownership = "public"
+
+    # Parse market cap
+    market_cap = _parse_compact_number(company_data.get("market_cap"))
+
+    # Build account dictionary with ProxyCurl-compatible field names
     account: Dict[str, Any] = {
-        "name": company_data.get("name"),
-        "domain": company_data.get("primary_domain"),
-        "website": company_data.get("website_url"),
+        # Primary identifiers - use ProxyCurl-compatible names
+        "name": company_data.get("name"),  # Keep for backward compatibility
+        "organization_name": company_data.get("name"),  # ProxyCurl-compatible
+        "domain": company_data.get("primary_domain"),  # Keep for backward compatibility
+        "primary_domain_of_organization": company_data.get("primary_domain"),  # ProxyCurl-compatible
+        "website": company_data.get("website_url"),  # Keep for backward compatibility
+        "organization_website": company_data.get("website_url"),  # ProxyCurl-compatible
+        "organization_linkedin_url": company_data.get("linkedin_url"),
+        
+        # Contact info
         "phone": phone,
         "fax": company_data.get("fax") or company_data.get("fax_number"),
-        "industry": industry,
-        "company_size": company_size,
+        
+        # Business details - use ProxyCurl-compatible names
+        "industry": industry,  # Keep for backward compatibility
+        "organization_industry": industry,  # ProxyCurl-compatible
+        "company_size": company_size,  # Keep for backward compatibility
+        "organization_size": company_size,  # ProxyCurl-compatible
         "founded_year": founded_year,
         "annual_revenue": annual_revenue,
         "type": company_data.get("type") or company_data.get("organization_type"),
-        "ownership": company_data.get("ownership"),
-        "organization_linkedin_url": company_data.get("linkedin_url"),
+        "ownership": ownership,
+        "description": company_data.get("description") or company_data.get("short_description"),
+        
+        # Address info
         "billing_street": billing_street,
         "billing_city": company_data.get("city"),
         "billing_state": company_data.get("state"),
@@ -1405,20 +1439,44 @@ def fill_in_company_properties(company_data: dict) -> dict:
         or company_data.get("zip")
         or company_data.get("zipcode"),
         "billing_country": company_data.get("country"),
-        "description": company_data.get("description"),
+        
+        # Build organization_hq_location like ProxyCurl does
+        "organization_hq_location": ", ".join(filter(None, [
+            company_data.get("city"),
+            company_data.get("state"),
+            company_data.get("country")
+        ])) or None,
+        
+        # Other fields
         "keywords": _parse_keywords(company_data.get("keywords")),
         "tags": [],
         "notes": [],
         "additional_properties": {
             "apollo_organization_id": company_data.get("id"),
+            "logo_url": company_data.get("logo_url"),
             "facebook_url": company_data.get("facebook_url"),
             "twitter_url": company_data.get("twitter_url"),
+            "angellist_url": company_data.get("angellist_url"),
+            "crunchbase_url": company_data.get("crunchbase_url"),
+            "blog_url": company_data.get("blog_url"),
             "funding_stage": company_data.get("latest_funding_stage"),
             "total_funding": company_data.get("total_funding"),
             "technology_names": company_data.get("technology_names"),
             "primary_phone": primary_phone if isinstance(primary_phone, dict) else None,
             "raw_address": company_data.get("raw_address"),
             "organization_revenue_printed": company_data.get("organization_revenue_printed"),
+            "publicly_traded_symbol": company_data.get("publicly_traded_symbol"),
+            "publicly_traded_exchange": company_data.get("publicly_traded_exchange"),
+            "market_cap": market_cap,
+            "market_cap_printed": company_data.get("market_cap"),
+            "sic_codes": company_data.get("sic_codes"),
+            "naics_codes": company_data.get("naics_codes"),
+            "languages": company_data.get("languages"),
+            "alexa_ranking": company_data.get("alexa_ranking"),
+            "linkedin_uid": company_data.get("linkedin_uid"),
+            "headcount_6_month_growth": company_data.get("organization_headcount_six_month_growth"),
+            "headcount_12_month_growth": company_data.get("organization_headcount_twelve_month_growth"),
+            "headcount_24_month_growth": company_data.get("organization_headcount_twenty_four_month_growth"),
             "apollo_organization_data": json.dumps(cleanup_properties(company_data)),
         },
         "research_summary": None,
@@ -1726,3 +1784,341 @@ async def search_companies_with_apollo_page(
         "next_page": current_page + 1 if has_next_page else None,
         "results": companies
     }
+
+
+def _extract_domain_from_url(url: str) -> Optional[str]:
+    """
+    Extract domain from a URL.
+    
+    Args:
+        url: The URL to extract domain from
+        
+    Returns:
+        The extracted domain or None if extraction fails
+    """
+    if not url:
+        return None
+    
+    try:
+        # Handle URLs without scheme
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        
+        parsed = urlparse(url)
+        domain = parsed.netloc or parsed.path.split('/')[0]
+        
+        # Remove www. prefix if present
+        if domain.startswith('www.'):
+            domain = domain[4:]
+        
+        return domain if domain else None
+    except Exception:
+        return None
+
+
+def _extract_linkedin_company_identifier(linkedin_url: str) -> Optional[str]:
+    """
+    Extract the company identifier from a LinkedIn company URL.
+    
+    Args:
+        linkedin_url: LinkedIn company URL (e.g., https://www.linkedin.com/company/microsoft)
+        
+    Returns:
+        The company identifier (e.g., 'microsoft') or None if extraction fails
+    """
+    if not linkedin_url:
+        return None
+    
+    try:
+        # Normalize the URL
+        url = linkedin_url.strip().rstrip('/')
+        
+        # Handle various LinkedIn URL formats
+        # https://www.linkedin.com/company/microsoft
+        # https://linkedin.com/company/microsoft/
+        # linkedin.com/company/microsoft
+        
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        
+        parsed = urlparse(url)
+        path_parts = [p for p in parsed.path.split('/') if p]
+        
+        # Look for 'company' in path and get the next segment
+        if 'company' in path_parts:
+            company_idx = path_parts.index('company')
+            if company_idx + 1 < len(path_parts):
+                return path_parts[company_idx + 1]
+        
+        return None
+    except Exception:
+        return None
+
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def search_organization_by_linkedin_or_domain(
+    linkedin_url: Optional[str] = None,
+    domain: Optional[str] = None,
+    tool_config: Optional[List[Dict]] = None,
+) -> Dict[str, Any]:
+    """
+    Search for an organization in Apollo using LinkedIn URL or domain and return
+    standardized organization information.
+    
+    This function uses Apollo's mixed_companies/search endpoint to find companies
+    by their LinkedIn URL or domain, then transforms the result into a standardized
+    organization information format.
+    
+    Parameters:
+    - **linkedin_url** (*str*, optional): LinkedIn company URL 
+        (e.g., https://www.linkedin.com/company/microsoft)
+    - **domain** (*str*, optional): Company domain (e.g., microsoft.com)
+    
+    At least one of linkedin_url or domain must be provided.
+    
+    Returns:
+    - **dict**: Standardized organization information containing:
+        - name: Company name
+        - domain: Primary domain
+        - website: Company website URL
+        - phone: Primary phone number
+        - industry: Primary industry
+        - company_size: Number of employees
+        - founded_year: Year company was founded
+        - annual_revenue: Annual revenue
+        - organization_linkedin_url: LinkedIn company URL
+        - billing_street, billing_city, billing_state, billing_zip, billing_country: Address info
+        - description: Company description
+        - keywords: List of keywords/tags
+        - additional_properties: Additional Apollo-specific data
+        - error: Error message if search fails
+    """
+    logger.info("Entering search_organization_by_linkedin_or_domain")
+    
+    if not linkedin_url and not domain:
+        logger.warning("No linkedin_url or domain provided. At least one is required.")
+        return {'error': "At least one of linkedin_url or domain must be provided"}
+    
+    token, is_oauth = get_apollo_access_token(tool_config)
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache",
+    }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
+    
+    # Build the search payload
+    payload: Dict[str, Any] = {
+        "page": 1,
+        "per_page": 25,  # Get more results to improve matching
+    }
+    
+    # Add LinkedIn URL filter if provided
+    if linkedin_url:
+        # Extract the company identifier for keyword search
+        company_identifier = _extract_linkedin_company_identifier(linkedin_url)
+        
+        # Normalize the LinkedIn URL for matching
+        normalized_linkedin = linkedin_url.strip().rstrip('/')
+        if not normalized_linkedin.startswith(('http://', 'https://')):
+            normalized_linkedin = 'https://' + normalized_linkedin
+        
+        # Use q_organization_name for better search results
+        # The company identifier from LinkedIn URL is usually the company name
+        if company_identifier:
+            payload["q_organization_name"] = company_identifier
+    
+    # Add domain filter if provided
+    if domain:
+        # Clean the domain (remove http://, https://, www., etc.)
+        clean_domain = _extract_domain_from_url(domain) or domain
+        payload["q_organization_domains_list"] = [clean_domain]
+    
+    url = "https://api.apollo.io/api/v1/mixed_companies/search"
+    logger.debug(f"Making POST request to Apollo organization search with payload: {json.dumps(payload, indent=2)}")
+    
+    async with aiohttp.ClientSession() as session:
+        try:
+            async with session.post(url, headers=headers, json=payload) as response:
+                logger.debug(f"Received response status: {response.status}")
+                
+                if response.status == 200:
+                    result = await response.json()
+                    
+                    # Extract organizations from response
+                    organizations = result.get("organizations", [])
+                    accounts = result.get("accounts", [])
+                    all_results = organizations + accounts
+                    
+                    if not all_results:
+                        logger.info("No organizations found matching the criteria.")
+                        return {
+                            'error': 'No organizations found matching the provided criteria',
+                            'search_criteria': {
+                                'linkedin_url': linkedin_url,
+                                'domain': domain
+                            }
+                        }
+                    
+                    # Get the best matching organization with confidence tracking
+                    best_match = None
+                    match_confidence = None
+                    match_reason = None
+                    
+                    # If we have a domain, try to find exact match first (highest confidence)
+                    if domain:
+                        clean_domain = _extract_domain_from_url(domain) or domain
+                        for org in all_results:
+                            org_domain = org.get("primary_domain", "")
+                            if org_domain and org_domain.lower() == clean_domain.lower():
+                                best_match = org
+                                match_confidence = "high"
+                                match_reason = f"exact_domain_match: {org_domain}"
+                                logger.info(f"Found exact domain match: {org.get('name')} with domain {org_domain}")
+                                break
+                    
+                    # If we have LinkedIn URL, try to find exact match
+                    if not best_match and linkedin_url:
+                        # Extract company identifier from the input URL
+                        input_company_id = _extract_linkedin_company_identifier(linkedin_url)
+                        
+                        for org in all_results:
+                            org_linkedin = org.get("linkedin_url", "")
+                            org_name = org.get("name", "").lower()
+                            org_domain = org.get("primary_domain", "")
+                            
+                            if org_linkedin:
+                                # Extract company identifier from org's LinkedIn URL
+                                org_company_id = _extract_linkedin_company_identifier(org_linkedin)
+                                
+                                # Match by company identifier (e.g., 'walmart' matches 'walmart')
+                                if input_company_id and org_company_id:
+                                    if input_company_id.lower() == org_company_id.lower():
+                                        best_match = org
+                                        match_confidence = "high"
+                                        match_reason = f"linkedin_identifier_match: {org_company_id}"
+                                        logger.info(f"Found LinkedIn identifier match: {org.get('name')} with identifier {org_company_id}")
+                                        break
+                                
+                                # Also try direct URL comparison
+                                normalized_input = linkedin_url.lower().rstrip('/').replace('www.', '')
+                                normalized_org = org_linkedin.lower().rstrip('/').replace('www.', '')
+                                if normalized_input in normalized_org or normalized_org in normalized_input:
+                                    best_match = org
+                                    match_confidence = "high"
+                                    match_reason = f"linkedin_url_match: {org_linkedin}"
+                                    logger.info(f"Found LinkedIn URL match: {org.get('name')}")
+                                    break
+                            
+                            # Secondary match: company name contains the identifier
+                            if not best_match and input_company_id:
+                                # Check if the org name contains the identifier or vice versa
+                                input_id_lower = input_company_id.lower().replace('-', ' ').replace('_', ' ')
+                                org_name_normalized = org_name.replace('-', ' ').replace('_', ' ')
+                                
+                                if input_id_lower == org_name_normalized or input_id_lower in org_name_normalized:
+                                    best_match = org
+                                    match_confidence = "medium"
+                                    match_reason = f"name_contains_identifier: {org_name}"
+                                    logger.info(f"Found name match: {org.get('name')} matches identifier {input_company_id}")
+                                    break
+                    
+                    # If still no match and we searched by LinkedIn, return error if no exact match found
+                    if not best_match and linkedin_url and not domain:
+                        input_company_id = _extract_linkedin_company_identifier(linkedin_url)
+                        logger.warning(f"No organization found matching LinkedIn URL: {linkedin_url}")
+                        # Log what we did find for debugging
+                        found_orgs = [{"name": org.get("name"), "linkedin": org.get("linkedin_url"), "domain": org.get("primary_domain")} for org in all_results[:5]]
+                        logger.debug(f"Found organizations (first 5): {found_orgs}")
+                        return {
+                            'error': f'No organization found matching LinkedIn company: {input_company_id or linkedin_url}',
+                            'search_criteria': {
+                                'linkedin_url': linkedin_url,
+                                'domain': domain
+                            },
+                            'total_results_returned': len(all_results)
+                        }
+                    
+                    # Fall back to first result only if we have other criteria (domain was provided)
+                    if not best_match:
+                        best_match = all_results[0]
+                        match_confidence = "low"
+                        match_reason = "fallback_to_first_result"
+                        logger.warning(f"Using fallback match (first result): {best_match.get('name')}")
+                    
+                    # Get the organization ID to fetch full details
+                    organization_id = best_match.get("id")
+                    full_org_details = best_match  # Default to search result
+                    
+                    # Fetch full organization details using the organization ID
+                    if organization_id:
+                        logger.info(f"Fetching full organization details for ID: {organization_id}")
+                        try:
+                            full_details = await get_organization_details_from_apollo(
+                                organization_id=organization_id,
+                                tool_config=tool_config,
+                            )
+                            if full_details and not full_details.get("error"):
+                                # Merge the full details with the search result
+                                # Full details from organization endpoint has more data
+                                full_org_details = full_details
+                                logger.info(f"Successfully fetched full organization details for {full_org_details.get('name')}")
+                            else:
+                                logger.warning(f"Could not fetch full organization details: {full_details.get('error', 'Unknown error')}")
+                        except Exception as e:
+                            logger.warning(f"Error fetching full organization details: {e}")
+                    
+                    # Transform to standardized format using the full details
+                    standardized_org = fill_in_company_properties(full_org_details)
+                    
+                    # Add logo_url to additional_properties if available
+                    if full_org_details.get("logo_url"):
+                        standardized_org["additional_properties"]["logo_url"] = full_org_details.get("logo_url")
+                    
+                    # Add search metadata
+                    standardized_org['search_criteria'] = {
+                        'linkedin_url': linkedin_url,
+                        'domain': domain
+                    }
+                    standardized_org['total_matches_found'] = len(all_results)
+                    standardized_org['match_confidence'] = match_confidence
+                    standardized_org['match_reason'] = match_reason
+                    
+                    # Log the matched organization details for verification
+                    logger.info(f"Successfully found organization: {standardized_org.get('name')} "
+                               f"(domain: {standardized_org.get('domain')}, "
+                               f"linkedin: {standardized_org.get('organization_linkedin_url')}, "
+                               f"confidence: {match_confidence})")
+                    return standardized_org
+                    
+                elif response.status == 429:
+                    msg = "Rate limit exceeded"
+                    logger.warning(msg)
+                    await asyncio.sleep(30)
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status,
+                        message=msg,
+                        headers=response.headers
+                    )
+                else:
+                    result = await response.json()
+                    logger.warning(f"search_organization_by_linkedin_or_domain error: {result}")
+                    return {'error': result}
+                    
+        except aiohttp.ClientResponseError:
+            raise
+        except Exception as e:
+            logger.exception("Exception occurred while searching for organization in Apollo.")
+            return {'error': str(e)}

{dhisana-0.0.1.dev277 → dhisana-0.0.1.dev279}/src/dhisana/utils/enrich_lead_information.py

@@ -22,7 +22,7 @@ from dhisana.utils.field_validators import (
     validation_organization_domain,
     validate_website_url
 )
-from dhisana.utils.apollo_tools import enrich_user_info_with_apollo, enrich_person_info_from_apollo
+from dhisana.utils.apollo_tools import enrich_user_info_with_apollo, enrich_person_info_from_apollo, search_organization_by_linkedin_or_domain
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.domain_parser import get_domain_from_website, is_excluded_domain
 from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
@@ -804,25 +804,91 @@ async def enrich_organization_info_from_company_url(
 ) -> Dict[str, Any]:
     """
     Given an organization LinkedIn URL, attempt to enrich its data (e.g. name, website)
-    via ProxyCurl. Additional Proxycurl Company API boolean flags (categories, funding_data, etc.)
+    first via Apollo API, then fallback to ProxyCurl if Apollo doesn't return results.
+    Additional Proxycurl Company API boolean flags (categories, funding_data, etc.)
     can be supplied to control the returned payload (True -> "include"). If data is found,
     set domain, then return the dict. Otherwise, return {}.
     """
+    company_data = None
+    apollo_website = None
+    apollo_domain = None
 
-    # Call ProxyCurl to enrich
-    company_data = await enrich_organization_info_from_proxycurl(
-        organization_linkedin_url=organization_linkedin_url,
-        tool_config=tool_config,
-        categories=categories,
-        funding_data=funding_data,
-        exit_data=exit_data,
-        acquisitions=acquisitions,
-        extra=extra,
-        use_cache=use_cache,
-        fallback_to_cache=fallback_to_cache,
-    )
-
-    # If ProxyCurl returned any data, set domain, then return
+    # First, try Apollo API to get company information
+    try:
+        logger.debug(f"Attempting Apollo lookup for organization LinkedIn URL: {organization_linkedin_url}")
+        apollo_result = await search_organization_by_linkedin_or_domain(
+            linkedin_url=organization_linkedin_url,
+            tool_config=tool_config,
+        )
+        if apollo_result and not apollo_result.get("error"):
+            logger.debug(f"Apollo returned company data: {apollo_result.get('organization_name')}")
+            # Store Apollo's website and domain for later use
+            apollo_website = apollo_result.get("organization_website")
+            apollo_domain = apollo_result.get("primary_domain_of_organization")
+            
+            # If Apollo returned valid data, use it directly
+            # Apollo now returns ProxyCurl-compatible field names
+            if apollo_result.get("organization_name"):
+                company_data = {
+                    # Primary identifiers
+                    "organization_name": apollo_result.get("organization_name", ""),
+                    "organization_linkedin_url": apollo_result.get("organization_linkedin_url", organization_linkedin_url),
+                    "organization_website": apollo_result.get("organization_website", ""),
+                    "primary_domain_of_organization": apollo_result.get("primary_domain_of_organization", ""),
+                    
+                    # Contact info
+                    "phone": apollo_result.get("phone", ""),
+                    "fax": apollo_result.get("fax", ""),
+                    
+                    # Business details - use ProxyCurl-compatible names
+                    "organization_industry": apollo_result.get("organization_industry", ""),
+                    "industry": apollo_result.get("industry", ""),  # Keep for backward compatibility
+                    "organization_size": apollo_result.get("organization_size"),
+                    "company_size": apollo_result.get("company_size"),  # Keep for backward compatibility
+                    "founded_year": apollo_result.get("founded_year"),
+                    "annual_revenue": apollo_result.get("annual_revenue"),
+                    "type": apollo_result.get("type", ""),
+                    "ownership": apollo_result.get("ownership", ""),
+                    "description": apollo_result.get("description", ""),
+                    
+                    # Location info
+                    "organization_hq_location": apollo_result.get("organization_hq_location", ""),
+                    "billing_street": apollo_result.get("billing_street", ""),
+                    "billing_city": apollo_result.get("billing_city", ""),
+                    "billing_state": apollo_result.get("billing_state", ""),
+                    "billing_zip": apollo_result.get("billing_zip", ""),
+                    "billing_country": apollo_result.get("billing_country", ""),
+                    
+                    # Other fields
+                    "keywords": apollo_result.get("keywords", []),
+                    "additional_properties": apollo_result.get("additional_properties", {}),
+                }
+    except Exception as e:
+        logger.warning(f"Apollo lookup failed for {organization_linkedin_url}: {e}")
+
+    # If Apollo didn't return data, fallback to ProxyCurl
+    if not company_data:
+        logger.debug(f"Falling back to ProxyCurl for organization LinkedIn URL: {organization_linkedin_url}")
+        company_data = await enrich_organization_info_from_proxycurl(
+            organization_linkedin_url=organization_linkedin_url,
+            tool_config=tool_config,
+            categories=categories,
+            funding_data=funding_data,
+            exit_data=exit_data,
+            acquisitions=acquisitions,
+            extra=extra,
+            use_cache=use_cache,
+            fallback_to_cache=fallback_to_cache,
+        )
+        
+        # If ProxyCurl returned data but Apollo had better website/domain info, use Apollo's
+        if company_data and isinstance(company_data, dict):
+            if apollo_website and not company_data.get("organization_website"):
+                company_data["organization_website"] = apollo_website
+            if apollo_domain and not company_data.get("primary_domain_of_organization"):
+                company_data["primary_domain_of_organization"] = apollo_domain
+
+    # If we have company data, set domain and get research summary
     if company_data and isinstance(company_data, dict):
         await set_organization_domain(company_data, use_strict_check, tool_config)
         summary = await research_company_with_full_info_ai(company_data, "", tool_config=tool_config)