dhisana 0.0.1.dev277__py3-none-any.whl → 0.0.1.dev279__py3-none-any.whl

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/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)

dhisana/utils/test_connect.py

@@ -1869,6 +1869,151 @@ async def test_datagma(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(e)}
 
 
+###############################################################################
+#                         MICROSOFT DATAVERSE CONNECTIVITY
+###############################################################################
+
+async def test_dataverse(
+    environment_url: str,
+    tenant_id: str,
+    client_id: str,
+    client_secret: str,
+    api_version: str = "v9.2",
+) -> Dict[str, Any]:
+    """
+    Validate Microsoft Dataverse connectivity using client credentials OAuth.
+
+    Uses the OAuth 2.0 client credentials flow to obtain an access token from
+    Microsoft Entra ID, then makes a test API call to fetch sample accounts.
+
+    Required:
+      • environment_url  (e.g. https://org12345.crm.dynamics.com)
+      • tenant_id        (Microsoft Entra tenant GUID)
+      • client_id        (Application/client ID from app registration)
+      • client_secret    (Client secret from app registration)
+
+    Optional:
+      • api_version      (default: v9.2)
+    """
+    if not environment_url:
+        return {
+            "success": False,
+            "status_code": 0,
+            "error_message": "Missing environment_url for Dataverse.",
+        }
+    if not tenant_id:
+        return {
+            "success": False,
+            "status_code": 0,
+            "error_message": "Missing tenant_id for Dataverse.",
+        }
+    if not client_id:
+        return {
+            "success": False,
+            "status_code": 0,
+            "error_message": "Missing client_id for Dataverse.",
+        }
+    if not client_secret:
+        return {
+            "success": False,
+            "status_code": 0,
+            "error_message": "Missing client_secret for Dataverse.",
+        }
+
+    # Normalize environment URL
+    environment_url = environment_url.rstrip("/")
+
+    # Token endpoint and scope for client credentials flow
+    token_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
+    scope = f"{environment_url}/.default"
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=15)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            # Step 1: Get access token using client credentials
+            token_data = {
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "grant_type": "client_credentials",
+                "scope": scope,
+            }
+
+            async with session.post(
+                token_url,
+                data=token_data,
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            ) as token_response:
+                token_status = token_response.status
+                token_json = await safe_json(token_response)
+
+                if token_status != 200:
+                    error_msg = None
+                    if isinstance(token_json, dict):
+                        error_msg = (
+                            token_json.get("error_description")
+                            or token_json.get("error")
+                            or token_json.get("message")
+                        )
+                    return {
+                        "success": False,
+                        "status_code": token_status,
+                        "error_message": error_msg or f"Token acquisition failed: {token_status}",
+                    }
+
+                access_token = token_json.get("access_token") if token_json else None
+                if not access_token:
+                    return {
+                        "success": False,
+                        "status_code": token_status,
+                        "error_message": "No access_token in token response.",
+                    }
+
+            # Step 2: Test API access by fetching sample accounts
+            api_url = f"{environment_url}/api/data/{api_version}/accounts"
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+                "OData-MaxVersion": "4.0",
+                "OData-Version": "4.0",
+            }
+            params = {"$top": "5", "$select": "name,accountid"}
+
+            async with session.get(api_url, headers=headers, params=params) as api_response:
+                api_status = api_response.status
+                api_data = await safe_json(api_response)
+
+                if api_status != 200:
+                    error_msg = None
+                    if isinstance(api_data, dict):
+                        # Dataverse error format
+                        error_obj = api_data.get("error", {})
+                        if isinstance(error_obj, dict):
+                            error_msg = error_obj.get("message")
+                        else:
+                            error_msg = api_data.get("message") or api_data.get("error")
+                    return {
+                        "success": False,
+                        "status_code": api_status,
+                        "error_message": error_msg or f"Dataverse API error: {api_status}",
+                    }
+
+                # Success - check if we got valid data
+                if isinstance(api_data, dict) and "value" in api_data:
+                    record_count = len(api_data.get("value", []))
+                    return {
+                        "success": True,
+                        "status_code": api_status,
+                        "error_message": None,
+                        "message": f"Connected successfully. Found {record_count} sample accounts.",
+                    }
+
+                return {"success": True, "status_code": api_status, "error_message": None}
+
+    except Exception as exc:
+        logger.error(f"Dataverse connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
 ###############################################################################
 #                         MAIN CONNECTIVITY FUNCTION
 ###############################################################################
@@ -1902,6 +2047,7 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "hunter":           test_hunter,
         "findymail":        test_findyemail,
         "datagma":          test_datagma,
+        "dataverse":        test_dataverse,
         "jinaai":           test_jinaai,
         "firefliesai":      test_firefliesai,
         "firecrawl":        test_firecrawl,
@@ -2145,6 +2291,57 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
                 results[tool_name] = await test_twilio(account_sid, auth_token)
             continue
 
+        # ------------------------------------------------------------------ #
+        # Special-case: Dataverse (client credentials OAuth)
+        # ------------------------------------------------------------------ #
+        if tool_name == "dataverse":
+            environment_url = next(
+                (c["value"] for c in config_entries if c["name"] in ("environment_url", "environmentUrl")),
+                None,
+            )
+            tenant_id = next(
+                (c["value"] for c in config_entries if c["name"] in ("tenant_id", "tenantId")),
+                None,
+            )
+            client_id = next(
+                (c["value"] for c in config_entries if c["name"] in ("client_id", "clientId")),
+                None,
+            )
+            client_secret = next(
+                (c["value"] for c in config_entries if c["name"] in ("client_secret", "clientSecret")),
+                None,
+            )
+            api_version = next(
+                (c["value"] for c in config_entries if c["name"] in ("api_version", "apiVersion")),
+                "v9.2",
+            )
+
+            if not all([environment_url, tenant_id, client_id, client_secret]):
+                missing = []
+                if not environment_url:
+                    missing.append("environment_url")
+                if not tenant_id:
+                    missing.append("tenant_id")
+                if not client_id:
+                    missing.append("client_id")
+                if not client_secret:
+                    missing.append("client_secret")
+                results[tool_name] = {
+                    "success": False,
+                    "status_code": 0,
+                    "error_message": f"Missing required fields: {', '.join(missing)}",
+                }
+            else:
+                logger.info("Testing connectivity for Dataverse…")
+                results[tool_name] = await test_dataverse(
+                    environment_url,
+                    tenant_id,
+                    client_id,
+                    client_secret,
+                    api_version,
+                )
+            continue
+
         # ------------------------------------------------------------------ #
         # All other tools – expect an apiKey by default
         # ------------------------------------------------------------------ #

{dhisana-0.0.1.dev277.dist-info → dhisana-0.0.1.dev279.dist-info}/METADATA

@@ -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.dist-info → dhisana-0.0.1.dev279.dist-info}/RECORD

@@ -12,7 +12,7 @@ dhisana/ui/components.py,sha256=4NXrAyl9tx2wWwoVYyABO-EOGnreGMvql1AkXWajIIo,1431
 dhisana/utils/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
 dhisana/utils/add_mapping.py,sha256=oq_QNqag86DhgdwINBRRXNx7SOb8Q9M-V0QLP6pTzr8,13837
 dhisana/utils/agent_tools.py,sha256=pzBFvfhU4wfSB4zv1eiRzjmnteJnfhC5V32r_v1m38Y,2321
-dhisana/utils/apollo_tools.py,sha256=Yjs594qP5Q86ZaIJzSGJ7sgWdvitc3LXLocg9FPnZ8Y,70606
+dhisana/utils/apollo_tools.py,sha256=o25JvQPo5__Uyv1PAWxD_PYbklof3cto5osHmnaccHE,90193
 dhisana/utils/assistant_tool_tag.py,sha256=rYRl8ubLI7fUUIjg30XTefHBkFgRqNEVC12lF6U6Z-8,119
 dhisana/utils/built_with_api_tools.py,sha256=TFNGhnPb2vFdveVCpjiCvE1WKe_eK95UPpR0Ha5NgMQ,10260
 dhisana/utils/cache_output_tools.py,sha256=q-d-WR_pkIUQyCJk8T-u9sfTy1TvvWoD2kJlZfqY-vA,4392
@@ -32,7 +32,7 @@ dhisana/utils/domain_parser.py,sha256=Kw5MPP06wK2azWQzuSiOE-DffOezLqDyF-L9JEBsMS
 dhisana/utils/email_body_utils.py,sha256=rlCVjdBlqNnEiUberJGXGcrYY1GQOkW0-aB6AEpS3L4,2302
 dhisana/utils/email_parse_helpers.py,sha256=rl72ggS-yoB-w3ZHW2sevKJulQ-_8iLdpVTH6QnKPcs,6789
 dhisana/utils/email_provider.py,sha256=ukW_0nHcjTQmpnE9pdJci78LrZcsK1_0v6kcgc2ChPY,14573
-dhisana/utils/enrich_lead_information.py,sha256=OBzUXdfaquRvjB9Z_bFq542tXJVwWnprGYB7QSjfjHQ,41246
+dhisana/utils/enrich_lead_information.py,sha256=9U6wkwe0REtmrfdMr7u6KW9N2SNg0Ei2cjyplVgdOh8,45411
 dhisana/utils/extract_email_content_for_llm.py,sha256=SQmMZ3YJtm3ZI44XiWEVAItcAwrsSSy1QzDne7LTu_Q,3713
 dhisana/utils/fetch_openai_config.py,sha256=LjWdFuUeTNeAW106pb7DLXZNElos2PlmXRe6bHZJ2hw,5159
 dhisana/utils/field_validators.py,sha256=BZgNCpBG264aRqNUu_J67c6zfr15zlAaIw2XRy8J7DY,11809
@@ -81,7 +81,7 @@ dhisana/utils/serperdev_google_jobs.py,sha256=m5_2f_5y79FOFZz1A_go6m0hIUfbbAoZ0Y
 dhisana/utils/serperdev_local_business.py,sha256=JoZfTg58Hojv61cyuwA2lcnPdLT1lawnWaBNrUYWnuQ,6447
 dhisana/utils/serperdev_search.py,sha256=_iBKIfHMq4gFv5StYz58eArriygoi1zW6VnLlux8vto,9363
 dhisana/utils/smtp_email_tools.py,sha256=peW0dKMUW5s_yso9uhLb6DGOM3Aj028zshqBWlQKviE,21990
-dhisana/utils/test_connect.py,sha256=tp9mdd_aGMeqq1FSkELfgiiQ6kgk4JPcOahKYwBicck,92434
+dhisana/utils/test_connect.py,sha256=PFwCQ6ODzXGdUV0kXREed8U2FG_emizlDF-wG9r51wQ,100367
 dhisana/utils/trasform_json.py,sha256=7V72XNDpuxUX0GHN5D83z4anj_gIf5zabaHeQm7b1_E,6979
 dhisana/utils/web_download_parse_tools.py,sha256=ouXwH7CmjcRjoBfP5BWat86MvcGO-8rLCmWQe_eZKjc,7810
 dhisana/utils/workflow_code_model.py,sha256=YPWse5vBb3O6Km2PvKh1Q3AB8qBkzLt1CrR5xOL9Mro,99
@@ -95,8 +95,8 @@ dhisana/workflow/agent.py,sha256=esv7_i_XuMkV2j1nz_UlsHov_m6X5WZZiZm_tG4OBHU,565
 dhisana/workflow/flow.py,sha256=xWE3qQbM7j2B3FH8XnY3zOL_QXX4LbTW4ArndnEYJE0,1638
 dhisana/workflow/task.py,sha256=HlWz9mtrwLYByoSnePOemBUBrMEcj7KbgNjEE1oF5wo,1830
 dhisana/workflow/test.py,sha256=E7lRnXK0PguTNzyasHytLzTJdkqIPxG5_4qk4hMEeKc,3399
-dhisana-0.0.1.dev277.dist-info/METADATA,sha256=aXZ6EqTc5mZCHkS4fJiDuleY4FStxUNOC1AbYQ2sUnE,1190
-dhisana-0.0.1.dev277.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-dhisana-0.0.1.dev277.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
-dhisana-0.0.1.dev277.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
-dhisana-0.0.1.dev277.dist-info/RECORD,,
+dhisana-0.0.1.dev279.dist-info/METADATA,sha256=6Zksvpdsjon8UlBdVEoWtlHjoRFVxfI8HwOyFWwmWoE,1190
+dhisana-0.0.1.dev279.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dhisana-0.0.1.dev279.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
+dhisana-0.0.1.dev279.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
+dhisana-0.0.1.dev279.dist-info/RECORD,,