dhisana 0.0.1.dev33__tar.gz → 0.0.1.dev34__tar.gz

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/PKG-INFO

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

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/setup.py

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

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/src/dhisana/schemas/sales.py

@@ -279,4 +279,172 @@ HUBSPOT_TO_LEAD_MAPPING = {
     "address": "lead_location",         # You can choose "city", "state", etc. if you prefer
     "city": "lead_location",
     "domain": "primary_domain_of_organization",
-}
+}
+
+
+
+class SmartListStatus(str, Enum):
+    DRAFT = "DRAFT"
+    ACTIVE = "ACTIVE"
+    COMPLETED = "COMPLETED"
+
+
+class SmartList(BaseModel):
+    id: Optional[UUID] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    instructions: Optional[str] = None
+    max_leads: Optional[int] = None
+    use_online_search: Optional[bool] = False
+    category: Optional[str] = None
+
+    status: SmartListStatus = SmartListStatus.DRAFT
+    start_date: Optional[int] = None
+    end_date: Optional[int] = None
+
+    agent_instance_id: Optional[UUID] = None
+    organization_id: Optional[UUID] = None
+    created_by: Optional[UUID] = None
+    created_at: Optional[int] = None
+    updated_by: Optional[UUID] = None
+    updated_at: Optional[int] = None
+
+    class Config:
+        from_attributes = True
+
+
+class SmartListLead(BaseModel):
+    id: Optional[UUID] = None
+
+    smart_list_id: Optional[UUID] = None
+
+    full_name: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    email: Optional[str] = None
+    user_linkedin_url: Optional[str] = None
+    user_linkedin_salesnav_url: Optional[str] = None
+    organization_linkedin_url: Optional[str] = None
+    organization_linkedin_salesnav_url: Optional[str] = None
+    primary_domain_of_organization: Optional[str] = None
+    job_title: Optional[str] = None
+    phone: Optional[str] = None
+    headline: Optional[str] = None
+    lead_location: Optional[str] = None
+    organization_name: Optional[str] = None
+    organization_website: Optional[str] = None
+    summary_about_lead: Optional[str] = None
+    keywords: Optional[List[str]] = None
+    additional_properties: Optional[Dict[str, str]] = None
+    research_summary: Optional[str] = None
+
+    qualification_score: Optional[float] = None
+    qualification_reason: Optional[str] = None
+    source: Optional[str] = None
+
+    agent_instance_id: Optional[UUID] = None
+    organization_id: Optional[UUID] = None
+    created_by: Optional[UUID] = None
+    created_at: Optional[int] = None
+    updated_by: Optional[UUID] = None
+    updated_at: Optional[int] = None
+
+    class Config:
+        from_attributes = True
+
+
+class SmartListLog(BaseModel):
+    id: Optional[UUID] = None
+    message: str
+
+    smart_list_id: UUID
+
+    agent_instance_id: Optional[UUID] = None
+    organization_id: Optional[UUID] = None
+    created_by: Optional[UUID] = None
+    created_at: Optional[int] = None
+    updated_by: Optional[UUID] = None
+    updated_at: Optional[int] = None
+
+    class Config:
+        from_attributes = True
+
+class LeadsQueryFilters(BaseModel):
+    """
+    Defines the filter parameters used to query leads in the Apollo database.
+    All fields are optional and will default to None if not specified by user.
+    """
+    # Existing fields
+    job_titles_to_search: Optional[List[str]] = Field(
+        default=None, 
+        description="List of job titles to include in the search."
+    )
+    locations_to_search: Optional[List[str]] = Field(
+        default=None, 
+        description="List of personal locations (cities, states, countries)."
+    )
+    min_number_of_employees_in_organization: Optional[int] = Field(
+        default=None, 
+        description="Minimum number of employees (>=1). Default=1 if omitted."
+    )
+    max_number_of_employees_in_organization: Optional[int] = Field(
+        default=None, 
+        description="Maximum number of employees (<=100000). Default=1000 if omitted."
+    )
+    filter_by_signals: Optional[List[str]] = Field(
+        default=None, 
+        description="List of signals to filter by, e.g. ['RECENT_JOB_CHANGE']."
+    )
+    max_number_of_items_to_return: Optional[int] = Field(
+        default=None, 
+        description="Max # of items (<=5000). Default=100."
+    )
+    industries: Optional[List[str]] = Field(
+        default=None, 
+        description="List of industries. Default=[] if omitted."
+    )
+
+    # Fields that were not previously used by the search, but can exist
+    min_revenue_of_the_company: Optional[int] = Field(
+        default=None, 
+        description="Minimum company revenue (not currently used in People Search)."
+    )
+    max_revenue_of_the_company: Optional[int] = Field(
+        default=None, 
+        description="Maximum company revenue (not currently used in People Search)."
+    )
+    job_functions: Optional[List[str]] = Field(
+        default=None, 
+        description="List of job functions (not directly used by the new People Search)."
+    )
+
+    # --------------------------------------------------
+    # New fields from the updated Apollo doc
+    # --------------------------------------------------
+    q_keywords: Optional[str] = Field(
+        default=None,
+        description="A string of keywords to filter results."
+    )
+    organization_domains: Optional[List[str]] = Field(
+        default=None,
+        description="Domains of the person's employer (e.g., ['microsoft.com'])."
+    )
+    organization_locations: Optional[List[str]] = Field(
+        default=None,
+        description="List of HQ locations for the employer (city, state, country)."
+    )
+    contact_email_status: Optional[List[str]] = Field(
+        default=None,
+        description="Email statuses to filter by, e.g. ['verified', 'unavailable']."
+    )
+    organization_ids: Optional[List[str]] = Field(
+        default=None,
+        description="Apollo IDs for the companies/employers (string IDs)."
+    )
+    person_seniorities: Optional[List[str]] = Field(
+        default=None,
+        description="List of job seniorities, e.g. ['manager', 'director', 'vp']. "
+                    "Apollo supports: owner, founder, c_suite, partner, vp, head, "
+                    "director, manager, senior, entry, intern."
+    )
+

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/src/dhisana/utils/agent_task.py

@@ -55,7 +55,7 @@ async def execute_task(
 
     # Unique ID for this request
     request_id = str(uuid.uuid4())
-    api_base_url = os.environ.get("AGENT_SERVICE_URL", "https://api.dhisana.ai/v1")
+    api_base_url = os.environ.get("AGENT_SERVICE_URL", "https://api-agent.dhisana.ai/v1")
 
     # The payload to send when adding a task
     payload = {

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/src/dhisana/utils/apollo_tools.py

@@ -5,8 +5,11 @@ import logging
 import os
 import aiohttp
 import backoff
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from datetime import datetime, timedelta
+
+from pydantic import BaseModel
+from dhisana.schemas.sales import LeadsQueryFilters, SmartList, SmartListLead
 from dhisana.utils.cache_output_tools import cache_output,retrieve_output
 from dhisana.utils.assistant_tool_tag import assistant_tool
 
@@ -272,87 +275,81 @@ async def fetch_apollo_data(session, url, headers, payload):
             response.raise_for_status()
 
 
+   
+# --------------------------------------------------
+# The People Search Function
+# --------------------------------------------------
 
-@assistant_tool
 async def search_people_with_apollo(
-    job_titles: List[str],
-    locations: List[str],
-    min_number_of_employees: int,
-    max_number_of_employees: int,
-    filter_by_signals: List[str],
-    max_number_of_items_to_return: int,
-    industries: List[str],
-    tool_config: Optional[List[Dict]] = None,
+    job_titles: List[str] = [],
+    locations: List[str] = [],
+    min_number_of_employees: int = 1,
+    max_number_of_employees: int = 1000,
+    filter_by_signals: List[str] = [],
+    max_number_of_items_to_return: int = 100,
+    industries: List[str] = [],
+    q_keywords: Optional[str] = None,
+    organization_domains: Optional[List[str]] = None,
+    organization_locations: Optional[List[str]] = None,
+    contact_email_status: Optional[List[str]] = None,
+    organization_ids: Optional[List[str]] = None,
+    person_seniorities: Optional[List[str]] = None,
+    tool_config: Optional[List[Dict[str, Any]]] = None
 ) -> List[Dict]:
     """
-    Search for individuals on Apollo based on specified criteria.
-
-    Parameters:
-    - **job_titles** (*List[str]*): Job titles to include in the search.
-    - **locations** (*List[str]*): Locations to filter the search.
-    - **min_number_of_employees** (*int*): Minimum number of employees in the organization.
-      Must be >= 1. Default is 1
-    - **max_number_of_employees** (*int*): Maximum number of employees in the organization.
-      Must be <= 100000 and greater than min_number_of_employees. Default 1000
-    - **filter_by_signals** (*List[str]*): Signals to filter by. Valid options:
-        - "RECENT_JOB_CHANGE"
-        - "RAPID_EXPANSION"
-    - **max_number_of_items_to_return** (*int*): Maximum number of results to return. Defaults to 100,
-      with a maximum allowed value of 5000.
-    - **industries** (*List[str]*): A list of industries to filter by. Defaults to [] for no filter. Default empty []
-
-    Returns:
-    - **List[Dict]**: A list of individual records (dictionaries) matching the specified criteria, 
-      or a single-item list containing a JSON-encoded error dictionary if an error occurs.
+    Searches Apollo using the People Search endpoint and returns raw results (people + contacts).
     """
 
-    # Validate min and max employees
+    # Validate min/max employees
     if min_number_of_employees < 1:
         raise ValueError("Minimum number of employees must be at least 1.")
     if max_number_of_employees > 100000:
         raise ValueError("Maximum number of employees must not exceed 100,000.")
     if min_number_of_employees >= max_number_of_employees:
-        raise ValueError("Minimum number of employees must be less than the maximum number.")
+        raise ValueError("Minimum employees must be less than maximum employees.")
 
-    APOLLO_API_KEY = get_apollo_access_token(tool_config)
-
-    # Log the search parameters for debugging
-    logging.info(
-        f"Initiating search with parameters: "
-        f"Job titles: {job_titles}, Locations: {locations}, "
-        f"Employee range: {min_number_of_employees}-{max_number_of_employees}, "
-        f"Signals: {filter_by_signals}, "
-        f"Industries: {industries}, "
-        f"Max items: {max_number_of_items_to_return}"
-    )
-
-    # Ensure a positive number of items to return
+    # Enforce search result limits
     if max_number_of_items_to_return <= 0:
         max_number_of_items_to_return = 10
+    elif max_number_of_items_to_return > 5000:
+        max_number_of_items_to_return = 5000
 
+    api_key = get_apollo_access_token(tool_config)
     headers = {
         "Cache-Control": "no-cache",
         "Content-Type": "application/json",
-        "X-Api-Key": APOLLO_API_KEY,
+        "X-Api-Key": api_key,
     }
 
-    # Apollo endpoint for searching
     url = "https://api.apollo.io/v1/mixed_people/search"
 
-    # Mapping of filter signals to their Apollo-specific IDs
+    # Convert signals to Apollo-specific IDs
     signal_mapping = {
         "RECENT_JOB_CHANGE": "643daa349293c1cdaa4d00f8",
-        "RAPID_EXPANSION": "643daa3f9293c1cdaa4d00fa"
+        "RAPID_EXPANSION": "643daa3f9293c1cdaa4d00fa",
     }
-
-    # Translate requested signals into Apollo signal IDs
     search_signal_ids = [signal_mapping[s] for s in filter_by_signals if s in signal_mapping]
 
+    logging.info(
+        f"Apollo Search:\n"
+        f"  job_titles={job_titles}\n"
+        f"  person_locations={locations}\n"
+        f"  organization_num_employees_ranges=[{min_number_of_employees},{max_number_of_employees}]\n"
+        f"  filter_by_signals={filter_by_signals}\n"
+        f"  industries={industries}\n"
+        f"  q_keywords={q_keywords}\n"
+        f"  organization_domains={organization_domains}\n"
+        f"  organization_locations={organization_locations}\n"
+        f"  contact_email_status={contact_email_status}\n"
+        f"  organization_ids={organization_ids}\n"
+        f"  person_seniorities={person_seniorities}\n"
+        f"  max_items={max_number_of_items_to_return}"
+    )
+
     async with aiohttp.ClientSession() as session:
         results = []
         page = 1
-        # Apollo API allows up to 100 items per page
-        per_page = min(max_number_of_items_to_return, 100)
+        per_page = min(max_number_of_items_to_return, 100)  # 100 max per page
 
         while len(results) < max_number_of_items_to_return:
             payload = {
@@ -361,53 +358,158 @@ async def search_people_with_apollo(
                 "search_signal_ids": search_signal_ids,
                 "organization_num_employees_ranges": [f"{min_number_of_employees},{max_number_of_employees}"],
                 "page": page,
-                "per_page": per_page
+                "per_page": per_page,
             }
 
-            # Include industries filter if provided
+            # Conditionally add new parameters
+            if q_keywords:
+                payload["q_keywords"] = q_keywords
+            if organization_domains:
+                payload["q_organization_domains"] = organization_domains
+            if organization_locations:
+                payload["organization_locations"] = organization_locations
+            if contact_email_status:
+                payload["contact_email_status"] = contact_email_status
+            if organization_ids:
+                payload["organization_ids"] = organization_ids
+            if person_seniorities:
+                payload["person_seniorities"] = person_seniorities
             if industries:
                 payload["organization_industries"] = industries
 
             try:
                 data = await fetch_apollo_data(session, url, headers, payload)
-                people = data.get('people', [])
-                contacts = data.get('contacts', [])
+                people = data.get("people", [])
+                contacts = data.get("contacts", [])
 
-                # If no results found, stop the loop
                 if not people and not contacts:
-                    break
+                    break  # No more results
 
-                # Add the retrieved results
                 results.extend(people + contacts)
 
-                # Handle pagination
-                pagination = data.get('pagination', {})
-                current_page = pagination.get('page', 1)
-                total_pages = pagination.get('total_pages', 1)
+                pagination = data.get("pagination", {})
+                current_page = pagination.get("page", 1)
+                total_pages = pagination.get("total_pages", 1)
 
                 if current_page >= total_pages:
-                    # No more pages to fetch
                     break
-
                 page += 1
 
             except aiohttp.ClientResponseError as e:
-                # If rate-limited, wait and retry
+                # Handle rate limiting
                 if e.status == 429:
                     await asyncio.sleep(30)
                 else:
-                    # Return error details as a JSON string in a list
                     error_details = {
-                        'status': e.status,
-                        'message': str(e),
-                        'url': str(e.request_info.url),
-                        'headers': dict(e.headers),
+                        "status": e.status,
+                        "message": str(e),
+                        "url": str(e.request_info.url),
+                        "headers": dict(e.headers),
                     }
-                    return [json.dumps(error_details)]
+                    return [error_details]  # Return partial error info
 
-        # Return only up to the requested number of items
         return results[:max_number_of_items_to_return]
 
+# --------------------------------------------------
+# Convert Apollo Search Results -> SmartListLead
+# --------------------------------------------------
+
+async def search_leads_with_apollo(
+    query: LeadsQueryFilters,
+    request: SmartList,
+    tool_config: Optional[List[Dict[str, Any]]] = None
+) -> List[SmartListLead]:
+    """
+    Given a LeadsQueryFilters object, run the Apollo People Search.
+    Format each result record as a SmartListLead.
+    """
+
+    # 1) Apply defaults if any field is None
+    job_titles = query.job_titles_to_search or []
+    locations = query.locations_to_search or []
+    min_employees = query.min_number_of_employees_in_organization or 1
+    max_employees = query.max_number_of_employees_in_organization or 1000
+    signals = query.filter_by_signals or []
+    max_items = request.max_leads or 10
+    if max_items > 2000:
+        max_items = 2000
+
+    industries = query.industries or []
+
+    # Additional filters
+    q_keywords = query.q_keywords
+    organization_domains = query.organization_domains or []
+    organization_locations = query.organization_locations or []
+    contact_email_status = query.contact_email_status or []
+    organization_ids = query.organization_ids or []
+    person_seniorities = query.person_seniorities or []
+
+    # 2) Fetch raw results (list of dict) from Apollo
+    results = await search_people_with_apollo(
+        job_titles=job_titles,
+        locations=locations,
+        min_number_of_employees=min_employees,
+        max_number_of_employees=max_employees,
+        filter_by_signals=signals,
+        max_number_of_items_to_return=max_items,
+        industries=industries,
+        q_keywords=q_keywords,
+        organization_domains=organization_domains,
+        organization_locations=organization_locations,
+        contact_email_status=contact_email_status,
+        organization_ids=organization_ids,
+        person_seniorities=person_seniorities,
+        tool_config=tool_config
+    )
+
+    # 3) Convert raw results into SmartListLead objects
+    leads_list: List[SmartListLead] = []
+    for apollo_person in results:
+        # Apollo typically returns fields like "name", "first_name", "last_name", etc.
+        # "organization" can be nested.
+        org_data = apollo_person.get("organization", {})
+
+        lead = SmartListLead(
+            # Map standard fields
+            full_name=apollo_person.get("name"),
+            first_name=apollo_person.get("first_name"),
+            last_name=apollo_person.get("last_name"),
+            email=apollo_person.get("email"),
+            user_linkedin_url=apollo_person.get("linkedin_url"),
+            phone=apollo_person.get("contact", {}).get("sanitized_phone"),
+            job_title=apollo_person.get("title"),
+            headline=apollo_person.get("headline"),
+
+            # Map organization fields
+            organization_name=org_data.get("name"),
+            organization_linkedin_url=org_data.get("linkedin_url"),
+            organization_website=org_data.get("website_url"),
+            primary_domain_of_organization=org_data.get("primary_domain"),
+
+            # We can combine city/state or anything else for "lead_location"
+            lead_location=", ".join(
+                filter(None, [apollo_person.get("city", ""), apollo_person.get("state", "")])
+            ) or None,
+
+            # For demonstration, fill from the request if needed
+            agent_instance_id=request.agent_instance_id,
+            organization_id=request.organization_id,
+            created_by=None,  # You could set this to request.created_by, etc.
+        )
+        
+        if "domain.com" in lead.email:
+            lead.email = ""
+
+        # If Apollo returns extra fields you'd like to preserve, store them in additional_properties
+        # as JSON or key/value pairs:
+        additional_props = {}
+        # e.g., store the entire record or partial:
+        additional_props["raw_apollo_data"] = json.dumps(apollo_person)
+        lead.additional_properties = additional_props
+
+        leads_list.append(lead)
+
+    return leads_list
     
 @assistant_tool
 async def get_organization_domain_from_apollo(

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/src/dhisana/utils/check_for_intent_signal.py

@@ -14,6 +14,7 @@ logging.basicConfig(level=logging.INFO)
 
 class IntentSignalScoring(BaseModel):
     score_based_on_intent_signal: int
+    reasoning_for_score_bing_high: str
 
 
 async def check_for_intent_signal(
@@ -27,21 +28,24 @@ async def check_for_intent_signal(
     Evaluate a 'lead' for a specific intent signal and return an integer score from 0–5.
     """
 
+    logger.info("check_for_intent_signal called with lead=%s, intent_signal_type=%s", lead.get("full_name"), intent_signal_type)
+
     search_results_text = ""
     if add_search_results:
-        # Correctly call get_search_results_for_insights with intent_signal_type
+        logger.info("Fetching search results for lead='%s' with signal='%s'", lead.get("full_name"), intent_signal_type)
         search_results = await get_search_results_for_insights(
             lead=lead,
             english_description=signal_to_look_for_in_plan_english,
             intent_signal_type=intent_signal_type,
             tool_config=tool_config
         )
+        logger.info("Received search results count: %d", len(search_results))
 
-        # Build a readable string from returned queries and results
-        # Each item in 'search_results' is a dict: {"query": str, "results": <json-encoded list of SERP results>}
         for item in search_results:
             query_str = item.get("query", "")
             results_str = item.get("results", "")
+            logger.info("Search query: %s", query_str)
+            logger.info("Search results snippet: %s", results_str[:100])  # Show partial snippet
             search_results_text += f"Query: {query_str}\nResults: {results_str}\n\n"
 
     user_prompt = f"""
@@ -67,28 +71,32 @@ async def check_for_intent_signal(
 
     Return your answer in valid JSON with the key 'score_based_on_intent_signal'.
     Make sure it is an integer between 0 and 5.
+    Add small reasoning_for_score_bing_high describing why you gave the score score_based_on_intent_signal as high if you are giving high score.
     """
+    logger.info("Constructed user prompt for LLM.")
 
-    logger.info("Scoring intent signal '%s' for lead: %s", intent_signal_type, lead.get("full_name", "Unknown"))
-
-    # The helper returns (model_instance or None, status_str)
     response_any, status = await get_structured_output_internal(
         user_prompt,
         IntentSignalScoring,
         tool_config=tool_config
     )
+    logger.info("Intent signal scoring call completed with status=%s", status)
 
     if status != "SUCCESS" or response_any is None:
+        logger.error("Failed to generate an intent signal score from the LLM.")
         raise Exception("Failed to generate an intent signal score from the LLM.")
 
-    # Cast to your specific model so the type checker is satisfied
     response = cast(IntentSignalScoring, response_any)
     score = response.score_based_on_intent_signal
+    reasoning = response.reasoning_for_score_bing_high[:200]  # Show partial if very long
+    lead["qualification_score"] = score
+    lead["qualification_reason"] = response.reasoning_for_score_bing_high
 
     logger.info(
-        "Lead '%s' scored %d for intent signal '%s'.",
+        "Lead '%s' scored %d for intent signal '%s'. Reason partial: %s",
         lead.get("full_name", "Unknown"),
         score,
-        intent_signal_type
+        intent_signal_type,
+        reasoning
     )
-    return score
+    return score

{dhisana-0.0.1.dev33 → dhisana-0.0.1.dev34}/src/dhisana/utils/compose_three_step_workflow.py

@@ -8,8 +8,8 @@ from dhisana.utils.generate_structured_output_internal import get_structured_out
 from dhisana.utils.workflow_code_model import WorkflowPythonCode
 
 # Example imports: adapt paths to your actual modules
-from dhisana.utils.create_list_from_sales_navigator import generate_sales_nav_list_workflow_and_execute
-from dhisana.utils.create_smart_list import generate_smart_list_creation_code_and_execute
+from dhisana.utils.generate_leads import generate_leads
+from dhisana.utils.qualify_leads import qualify_leads
 from dhisana.utils.compose_cadence import generate_campaign_cadence_workflow_and_execute
 
 # Initialize logger
@@ -127,7 +127,7 @@ async def generate_three_step_workflow_execute(
         else:
             # We interpret step_1_instructions as a user query for sales nav
             logger.info("Generating leads from sales nav instructions: %s", step_1_instructions)
-            result_str = await generate_sales_nav_list_workflow_and_execute(
+            result_str = await generate_leads(
                 user_query=step_1_instructions,
                 tool_config=tool_config
             )
@@ -162,7 +162,7 @@ async def generate_three_step_workflow_execute(
             try:
                 # generate_smart_list_creation_code_and_execute typically returns JSON:
                 # { "status": "SUCCESS", "qualified_leads": [...] }
-                result_str = await generate_smart_list_creation_code_and_execute(
+                result_str = await qualify_leads(
                     user_query=step_2_instructions,
                     input_leads_list=leads_list,
                     tool_config=tool_config