dhisana 0.0.1.dev85__py3-none-any.whl → 0.0.1.dev236__py3-none-any.whl

dhisana/schemas/common.py

@@ -363,3 +363,36 @@ class Integration(IntegrationBase):
 
 Integration.model_rebuild()
 IntegrationUpdate.model_rebuild()
+
+class BodyFormat(str, Enum):
+    AUTO = "auto"
+    HTML = "html"
+    TEXT = "text"
+
+
+class SendEmailContext(BaseModel):
+    recipient: str
+    subject: str
+    body: str
+    sender_name: str
+    sender_email: str
+    labels: Optional[List[str]]
+    body_format: BodyFormat = BodyFormat.AUTO
+    
+class QueryEmailContext(BaseModel):
+    start_time: str
+    end_time: str
+    sender_email: str
+    unread_only: bool = True
+    labels: Optional[List[str]] = None
+    
+
+class ReplyEmailContext(BaseModel):
+    message_id: str
+    reply_body: str
+    sender_email: str
+    sender_name: str
+    fallback_recipient: Optional[str] = None
+    mark_as_read: str = "True"
+    add_labels: Optional[List[str]] = None
+    reply_body_format: BodyFormat = BodyFormat.AUTO

dhisana/schemas/sales.py

@@ -1,24 +1,31 @@
+import json
+
 from uuid import UUID
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 from typing import List, Optional, Dict, Any
 from enum import Enum
 from typing import Optional, List, Dict, Literal
 
-from dhisana.schemas.common import User
 
 # -----------------------------
 # Lead-List-Specific Schemas
 # -----------------------------
 
 class Lead(BaseModel):
-    id: Optional[str] = None
+    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
+    linkedin_follower_count: Optional[int] = None
     primary_domain_of_organization: Optional[str] = None
+    twitter_handle: Optional[str] = None
+    twitch_handle: Optional[str] = None
+    github_handle: Optional[str] = None
     job_title: Optional[str] = None
     phone: Optional[str] = None
     headline: Optional[str] = None
@@ -26,25 +33,69 @@ class Lead(BaseModel):
     organization_name: Optional[str] = None
     organization_website: Optional[str] = None
     summary_about_lead: Optional[str] = None
+
+    qualification_score: Optional[float] = None
+    qualification_reason: Optional[str] = None
+    revenue: Optional[str] = None
+    company_size: Optional[str] = None
+    industry: Optional[str] = None
+
+    keywords: Optional[Any] = None
+    tags: List[str] = []
+    notes: List[str] = []
+    additional_properties: Optional[Dict[str, Any]] = {}
     workflow_stage: Optional[str] = None
-    assigned_to: Optional[str] = None
-    engaged: Optional[bool] = None
+
+    engaged: bool = False
     last_contact: Optional[int] = None
-    additional_properties: Optional[Dict[str, str]] = None
     research_summary: Optional[str] = None
     task_ids: Optional[List[str]] = None
-    email_validation_status: Optional[
-        Literal["not_started", "in_progress", "valid", "invalid"]
-    ] = None
-    linkedin_validation_status: Optional[
-        Literal["not_started", "in_progress", "valid", "invalid"]
-    ] = None
-    research_status: Optional[
-        Literal["not_started", "in_progress", "done", "failed"]
-    ] = None
-    enchrichment_status: Optional[
-        Literal["not_started", "in_progress", "done", "failed"]
-    ] = None
+    email_validation_status: Optional[str] = None
+    linkedin_validation_status: Optional[str] = None
+    research_status: Optional[str] = None
+    enchrichment_status: Optional[str] = None
+
+
+    @field_validator("linkedin_follower_count", mode="before")
+    @classmethod
+    def parse_linkedin_follower_count(cls, v):
+        if v is None or v == "":
+            return None
+        if isinstance(v, str):
+            v = v.strip()
+            if v == "":
+                return None
+            try:
+                return int(v)
+            except ValueError:
+                raise ValueError("linkedin_follower_count must be an integer")
+        return v
+
+    @field_validator("notes", mode="before")
+    @classmethod
+    def ensure_notes_list(cls, v):
+        """Coerce notes to a list of strings.
+        Handles legacy cases where the DB may contain a scalar or JSON string.
+        """
+        if v is None:
+            return []
+        if isinstance(v, list):
+            # Ensure all elements are strings
+            return [str(item) if not isinstance(item, str) else item for item in v]
+        if isinstance(v, str):
+            # Try to parse JSON array; if not, wrap as single-note list
+            try:
+                parsed = json.loads(v)
+                if isinstance(parsed, list):
+                    return [str(item) if not isinstance(item, str) else item for item in parsed]
+            except Exception:
+                pass
+            return [v]
+        # Fallback: wrap any other scalar/object as a single string entry
+        try:
+            return [json.dumps(v)]
+        except Exception:
+            return [str(v)]
 
 
 class LeadList(BaseModel):
@@ -240,9 +291,14 @@ class MessageGenerationInstructions(BaseModel):
     Holds the user-supplied instructions for generating the message:
       - instructions_to_generate_message: Plain text or template instructions from the user.
       - prompt_engineering_guidance: (Optional) Extra guidelines for structuring the prompt.
+      - allow_html: Whether HTML output is allowed.
+      - html_template: Optional HTML scaffolding or guidance.
     """
     instructions_to_generate_message: Optional[str] = None
     prompt_engineering_guidance: Optional[PromptEngineeringGuidance] = None
+    use_cache: Optional[bool] = True
+    allow_html: Optional[bool] = False
+    html_template: Optional[str] = None
 
 class CampaignContext(BaseModel):
     """
@@ -272,6 +328,10 @@ class MessageItem(BaseModel):
         ...,
         description="Unique identifier for the message"
     )
+    thread_id: str = Field(
+        ...,
+        description="Unique identifier for the conversation thread"
+    )
     sender_name: str = Field(
         ...,
         description="Sender's display name (if available)"
@@ -300,6 +360,7 @@ class MessageItem(BaseModel):
         ...,
         description="Body of the message in plain text"
     )
+    html_body: Optional[str] = None
 
 class MessageResponse(BaseModel):
     """
@@ -435,14 +496,14 @@ class HubSpotLeadInformation(BaseModel):
     organization_name: str = Field("", description="Current Company where lead works")
     organization_website: str = Field("", description="Current Company website of the lead")
     organization_linkedin_url : str = Field("", description="Company LinkedIn URL")
-    additional_properties: Optional[Dict[str, str]] = None
+    additional_properties: Optional[Dict[str, Any]] = None
 
 class HubSpotCompanyinformation(BaseModel):
     primary_domain_of_organization: str = Field("", description="Primary domain of the organization")
     organization_name: str = Field("", description="Current Company where lead works")
     organization_website: str = Field("", description="Current Company website of the lead")
     organization_linkedin_url : str = Field("", description="Company LinkedIn URL")
-    additional_properties: Optional[Dict[str, str]] = None
+    additional_properties: Optional[Dict[str, Any]] = None
 
 
 # --------------------------------------------------------------------
@@ -459,6 +520,7 @@ HUBSPOT_TO_LEAD_MAPPING = {
     "address": "lead_location",         # You can choose "city", "state", etc. if you prefer
     "city": "lead_location",
     "domain": "primary_domain_of_organization",
+    "hs_linkedin_url": "user_linkedin_url",
 }
 
 class SmartListStatus(str, Enum):
@@ -478,6 +540,12 @@ class SmartListSourceType(str, Enum):
     CSV = "CSV"
     GOOGLE_SHEETS = "GOOGLE_SHEETS"
     CUSTOM_WEBSITE = "CUSTOM_WEBSITE"
+    GITHUB = "GITHUB"
+    ICP_SEARCH = "ICP_SEARCH"
+    LOCAL_BUSINESS = "LOCAL_BUSINESS"
+    GOOGLE_JOBS = "GOOGLE_JOBS"
+    WEBHOOK = "WEBHOOK"
+    GOOGLE_CUSTOM_SITE_SEARCH = "GOOGLE_CUSTOM_SITE_SEARCH"
 
 class SourceConfiguration(BaseModel):
     """
@@ -494,6 +562,15 @@ class SourceConfiguration(BaseModel):
     file_path: Optional[str] = None
     # For Google Sheets
     source_url: Optional[str] = None
+    # For Github
+    github_search_query: Optional[str] = None
+    github_max_repos: Optional[int] = None
+    github_max_contributors: Optional[int] = None
+    
+    # Custom website inputs 
+    custom_instructions_for_doing_pagination: Optional[str] = None
+    custom_instructions_for_data_extraction_from_page: Optional[str] = None
+    custom_instruction_to_fetch_details_page: Optional[str] = None
 
 class SmartListSource(BaseModel):
     """
@@ -555,6 +632,8 @@ class SmartListLead(BaseModel):
     organization_linkedin_url: Optional[str] = None
     organization_linkedin_salesnav_url: Optional[str] = None
     primary_domain_of_organization: Optional[str] = None
+    twitter_handle: Optional[str] = None
+    github_handle: Optional[str] = None
     job_title: Optional[str] = None
     phone: Optional[str] = None
     headline: Optional[str] = None
@@ -562,13 +641,18 @@ class SmartListLead(BaseModel):
     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
+    keywords: Optional[Any] = None
+    additional_properties: Optional[Dict[str, Any]] = None
     research_summary: Optional[str] = None
 
     qualification_score: Optional[float] = None
     qualification_reason: Optional[str] = None
     source: Optional[str] = None
+    
+    email_validation_status: Optional[str] = None
+    linkedin_validation_status: Optional[str] = None
+    research_status: Optional[str] = None
+    enchrichment_status: Optional[str] = None
 
     agent_instance_id: Optional[UUID] = None
     organization_id: Optional[UUID] = None
@@ -576,7 +660,10 @@ class SmartListLead(BaseModel):
     created_at: Optional[int] = None
     updated_by: Optional[UUID] = None
     updated_at: Optional[int] = None
-
+    
+    revenue: Optional[str] = None
+    company_size: Optional[str] = None
+    industry: Optional[str] = None
     class Config:
         from_attributes = True
 
@@ -741,3 +828,117 @@ class LeadsQueryFilters(BaseModel):
         description="Ranges for organization number of employees."
     )
 
+
+class CompanyQueryFilters(BaseModel):
+    """
+    Defines the filter parameters for querying companies/organizations in the Apollo database.
+    All fields are optional and default to None if not specified by user.
+    """
+
+    # Core company search parameters
+    organization_locations: Optional[List[str]] = Field(
+        default=None,
+        description="List of organization headquarters locations (city, state, country)."
+    )
+
+    organization_num_employees_ranges: Optional[List[str]] = Field(
+        default=None,
+        description="Employee count ranges, e.g. ['1,10', '11,50', '51,200']. Use specific ranges."
+    )
+
+    min_employees: Optional[int] = Field(
+        default=None,
+        description="Minimum number of employees (>=1). Internally converted to a numeric range."
+    )
+    
+    max_employees: Optional[int] = Field(
+        default=None,
+        description="Maximum number of employees (<=100000). Internally converted to a numeric range."
+    )
+
+    organization_industries: Optional[List[str]] = Field(
+        default=None,
+        description="List of organization industries."
+    )
+
+    organization_industry_tag_ids: Optional[List[str]] = Field(
+        default=None,
+        description="List of industry tag IDs, e.g. ['5567cd4773696439b10b0000']."
+    )
+
+    # Revenue filters
+    revenue_range_min: Optional[int] = Field(
+        default=None,
+        description="Minimum company revenue in USD."
+    )
+    
+    revenue_range_max: Optional[int] = Field(
+        default=None,
+        description="Maximum company revenue in USD."
+    )
+
+    # Funding and growth
+    organization_latest_funding_stage_cd: Optional[List[str]] = Field(
+        default=None,
+        description="List of funding stage codes, e.g. ['2', '3', '10']."
+    )
+
+    # Technology and keywords
+    currently_using_any_of_technology_uids: Optional[List[str]] = Field(
+        default=None,
+        description="Technology UIDs used by the organization, e.g. ['google_font_api']."
+    )
+
+    q_keywords: Optional[str] = Field(
+        default=None,
+        description="Keywords to search for in company descriptions, names, etc."
+    )
+
+    q_organization_domains: Optional[List[str]] = Field(
+        default=None,
+        description="Specific company domains to search for, e.g. ['microsoft.com', 'google.com']."
+    )
+
+    # Company-specific filters
+    organization_ids: Optional[List[str]] = Field(
+        default=None,
+        description="Specific Apollo organization IDs to include."
+    )
+
+    not_organization_ids: Optional[List[str]] = Field(
+        default=None,
+        description="Apollo organization IDs to exclude from results."
+    )
+
+    # Search lists
+    q_organization_search_list_id: Optional[str] = Field(
+        default=None,
+        description="Include only organizations in a specific search list."
+    )
+    
+    q_not_organization_search_list_id: Optional[str] = Field(
+        default=None,
+        description="Exclude organizations in a specific search list."
+    )
+
+    # Sorting
+    sort_by_field: Optional[str] = Field(
+        default=None,
+        description="Sort field, e.g. 'name', 'employee_count', 'last_updated', etc."
+    )
+    
+    sort_ascending: Optional[bool] = Field(
+        default=None,
+        description="Sort ascending (True) or descending (False)."
+    )
+
+    # Additional filters that might be useful
+    organization_founded_year_min: Optional[int] = Field(
+        default=None,
+        description="Minimum founding year for the organization."
+    )
+    
+    organization_founded_year_max: Optional[int] = Field(
+        default=None,
+        description="Maximum founding year for the organization."
+    )

dhisana/utils/add_mapping.py

@@ -1,10 +1,7 @@
 import hashlib
-from urllib.parse import urlparse
 from typing import List, Optional
-import hashlib
 import logging
 from typing import Optional, Dict, Any
-from pydantic import ValidationError
 from dhisana.schemas.sales import MessageItem
 from dhisana.utils.cache_output_tools import (
     retrieve_output,
@@ -12,29 +9,38 @@ from dhisana.utils.cache_output_tools import (
 )
 from dhisana.utils.field_validators import normalize_linkedin_url, normalize_salesnav_url
 from dhisana.utils.parse_linkedin_messages_txt import parse_conversation
-logger = logging.getLogger(__name__)
 
+logger = logging.getLogger(__name__)
 
+def get_short_id_from_salesnav_url(sn_url: str) -> str:
+    import re
+    if not sn_url:
+        return ""
+    if "/sales/lead/" in sn_url:
+        pattern = r"linkedin\.com/sales/lead/([^/?#,]+)"
+        match = re.search(pattern, sn_url, re.IGNORECASE)
+        if not match:
+            return ""
+        sales_nav_id = re.sub(r"[^\w-]", "", match.group(1))
+        # Arbitrary example logic: if it starts with ACw or ACo, strip those and return 8 chars
+        if sales_nav_id.startswith("ACw") or sales_nav_id.startswith("ACo"):
+            return sales_nav_id[3:11]
+    return ""
 
 async def add_mapping_tool(mapping: dict) -> dict:
     """
     Create a two-way (forward & reverse) cache mapping between:
        - user_linkedin_url (normalized)
-       - user_linkedin_salesnav_url (normalized)
-    AND store single-direction entries for easy lookup:
-       - LN→SN   (key: "mapping_ln:<sha_of_ln>")
-       - SN→LN   (key: "mapping_sn:<sha_of_sn>")
+       - user_linkedin_salesnav_url (normalized, with short ID extracted if possible)
+
+    Also store single-direction entries for easy lookup:
+       - LN→SN   (key: "mapping_ln:<sha_of_normalized_ln>")
+       - SN→LN   (key: "mapping_sn:<sha_of_short_id_or_full_sn>")
 
     The cache content has the actual (raw) user-provided URLs,
     only the keys are lowercased/hashed.
 
     Returns a dict with status, message, and data.
-
-    Example 'mapping':
-    {
-        "user_linkedin_url": "linkedin.com/in/some-user/",
-        "user_linkedin_salesnav_url": "https://www.linkedin.com/sales/lead/123456,NAME_SEARCH"
-    }
     """
     user_linkedin_url = mapping.get("user_linkedin_url", "").strip()
     user_linkedin_salesnav_url = mapping.get("user_linkedin_salesnav_url", "").strip()
@@ -48,16 +54,19 @@ async def add_mapping_tool(mapping: dict) -> dict:
     # Normalize
     ln_url_norm = normalize_linkedin_url(user_linkedin_url)
     sn_url_norm = normalize_salesnav_url(user_linkedin_salesnav_url)
+    salesnav_short_id = get_short_id_from_salesnav_url(sn_url_norm)
+
+    # We'll use short_id in the forward/reverse *mapping strings*
+    forward_str = f"{ln_url_norm}→{salesnav_short_id}"
+    reverse_str = f"{salesnav_short_id}→{ln_url_norm}"
 
-    # Forward & reverse combined keys (to check if identical mapping was previously stored)
-    forward_str = f"{ln_url_norm}→{sn_url_norm}"
-    reverse_str = f"{sn_url_norm}→{ln_url_norm}"
     forward_key = "mapping:" + hashlib.sha256(forward_str.encode("utf-8")).hexdigest()
     reverse_key = "mapping:" + hashlib.sha256(reverse_str.encode("utf-8")).hexdigest()
 
-    # Check forward mapping
-    forward_cached = retrieve_output("tool_mappings", forward_key)
+    # Use the same namespace used later by the single-direction logic
+    forward_cached = retrieve_output("tool_mappings_linkedin_id", forward_key)
     if forward_cached:
+        # If we found an identical forward mapping, return success
         if (
             forward_cached.get("user_linkedin_url") == ln_url_norm
             and forward_cached.get("user_linkedin_salesnav_url") == sn_url_norm
@@ -68,12 +77,12 @@ async def add_mapping_tool(mapping: dict) -> dict:
                 "data": forward_cached
             }
 
-    # Check reverse mapping
-    reverse_cached = retrieve_output("tool_mappings", reverse_key)
+    reverse_cached = retrieve_output("tool_mappings_linkedin_id", reverse_key)
     if reverse_cached:
+        # If we found an identical reverse mapping, return success
         if (
             reverse_cached.get("user_linkedin_url") == ln_url_norm
-            and reverse_cached.get("user_linkedin_salesnav_url") == sn_url_norm
+            and reverse_cached.get("salesnav_short_id") == salesnav_short_id
         ):
             return {
                 "status": "SUCCESS",
@@ -84,34 +93,36 @@ async def add_mapping_tool(mapping: dict) -> dict:
     # Create object for storing in forward & reverse
     serialized_results = {
         "user_linkedin_url": ln_url_norm,
-        "user_linkedin_salesnav_url": sn_url_norm
+        "user_linkedin_salesnav_url": sn_url_norm,
+        "salesnav_short_id": salesnav_short_id
     }
 
-    # Store them
-    cache_output("tool_mappings", forward_key, serialized_results)
-    cache_output("tool_mappings", reverse_key, serialized_results)
+    # Store them in the same place we retrieve them from
+    cache_output("tool_mappings_linkedin_id", forward_key, serialized_results)
+    cache_output("tool_mappings_linkedin_id", reverse_key, serialized_results)
 
     # ------------------------------------------------------------------------
-    # Additional single-direction keys to enable easy lookups (raw usage):
-    #   LN key: "mapping_ln:<sha_of_normalized_ln.lower()>"
-    #   SN key: "mapping_sn:<sha_of_normalized_sn.lower()>"
-    # And store the *raw* original user URLs as requested
+    # Additional single-direction keys to enable easy lookups:
+    #   LN key: "mapping_ln:<sha_of_normalized_ln>"
+    #   SN key: "mapping_sn:<sha_of_short_id_or_full_sn>"
     # ------------------------------------------------------------------------
     ln_lower = ln_url_norm.lower()
-    sn_lower = sn_url_norm.lower()
 
+    # For SN, we prefer the short ID if it's not empty; otherwise fall back to the full URL.
+    sn_lookup_value = salesnav_short_id if salesnav_short_id else sn_url_norm
     ln_key = "mapping_ln:" + hashlib.sha256(ln_lower.encode("utf-8")).hexdigest()
-    sn_key = "mapping_sn:" + hashlib.sha256(sn_lower.encode("utf-8")).hexdigest()
+    sn_key = "mapping_sn:" + hashlib.sha256(sn_lookup_value.lower().encode("utf-8")).hexdigest()
 
-    # Cache the raw user-provided URLs
+    # Cache the raw user-provided (normalized) URLs
     single_direction_data = {
-        "raw_linkedin_url": ln_url_norm,   # no lowercasing
-        "raw_salesnav_url": sn_url_norm,   # no lowercasing
+        "raw_linkedin_url": ln_url_norm,    # no forced lowercasing in the stored data
+        "raw_salesnav_url": sn_url_norm,
+        "salesnav_short_id": salesnav_short_id
     }
     logger.info("mapping data cached: %s", single_direction_data)
 
-    cache_output("tool_mappings", ln_key, single_direction_data)
-    cache_output("tool_mappings", sn_key, single_direction_data)
+    cache_output("tool_mappings_linkedin_id", ln_key, single_direction_data)
+    cache_output("tool_mappings_linkedin_id", sn_key, single_direction_data)
 
     return {
         "status": "SUCCESS",
@@ -119,43 +130,42 @@ async def add_mapping_tool(mapping: dict) -> dict:
         "data": serialized_results
     }
 
-
 async def get_salesnav_url_for_linkedin_url(raw_ln_url: str) -> Optional[str]:
     """
     Given a LinkedIn URL, normalize it and look up the corresponding
     *raw* sales nav URL from the single-direction cache.
-    Return None if not found in cache.
+    Returns None if not found.
     """
-    # Normalize & lower-case for key
-    ln_norm = normalize_linkedin_url(raw_ln_url)
-    ln_key = "mapping_ln:" + hashlib.sha256(ln_norm.lower().encode("utf-8")).hexdigest()
+    ln_norm = normalize_linkedin_url(raw_ln_url).lower()
+    ln_key = "mapping_ln:" + hashlib.sha256(ln_norm.encode("utf-8")).hexdigest()
 
-    record = retrieve_output("tool_mappings", ln_key)
+    # Must retrieve from the same namespace we used when caching
+    record = retrieve_output("tool_mappings_linkedin_id", ln_key)
     if not record:
         return None
 
-    # record["raw_salesnav_url"] is the original user_linkedin_salesnav_url
     return record.get("raw_salesnav_url")
 
-
 async def get_linkedin_url_for_salesnav_url(raw_sn_url: str) -> Optional[str]:
     """
     Given a Sales Navigator URL, normalize it and look up the corresponding
     *raw* LinkedIn URL from the single-direction cache.
-    Return None if not found in cache.
+    Uses the short ID if available; otherwise falls back to the full SN URL.
+    Returns None if not found in cache.
     """
-    # Normalize & lower-case for key
     sn_norm = normalize_salesnav_url(raw_sn_url)
-    sn_key = "mapping_sn:" + hashlib.sha256(sn_norm.lower().encode("utf-8")).hexdigest()
+    salesnav_short_id = get_short_id_from_salesnav_url(sn_norm)
 
-    record = retrieve_output("tool_mappings", sn_key)
+    # Use short ID if present, else the normalized URL
+    sn_lookup_value = salesnav_short_id if salesnav_short_id else sn_norm
+    sn_key = "mapping_sn:" + hashlib.sha256(sn_lookup_value.lower().encode("utf-8")).hexdigest()
+
+    record = retrieve_output("tool_mappings_linkedin_id", sn_key)
     if not record:
         return None
 
-    # record["raw_linkedin_url"] is the original user_linkedin_url
     return record.get("raw_linkedin_url")
 
-
 async def cache_enriched_lead_info_from_salesnav(lead_info: dict, agent_id: str) -> Dict[str, Any]:
     """
     Cache lead information using the old SHA-256 approach if and only if:
@@ -263,7 +273,6 @@ async def retrieve_lead_html_from_salesnav(user_linkedin_url: str, agent_id: str
 
     return retrieve_output("tool_mappings", sn_key)
 
-
 async def cache_touchpoint_status(
     lead_info: Dict[str, Any],
     agent_id: str,
@@ -272,9 +281,8 @@ async def cache_touchpoint_status(
     """
     Cache TouchPointStatus data for a given lead.
     The cache key is generated from the SHA-256 hash of the normalized LinkedIn URL
-    and the sdr_user_id if available.
+    plus the agent_id.
     """
-    # ...existing code...
     if not lead_info or not lead_info.get("user_linkedin_url"):
         return {
             "status": "ERROR",
@@ -283,7 +291,6 @@ async def cache_touchpoint_status(
 
     user_linkedin_url = lead_info["user_linkedin_url"].strip()
     sn_norm = normalize_linkedin_url(user_linkedin_url)
-    
     sn_key = "touchpoint_status:" + hashlib.sha256((sn_norm.lower() + agent_id).encode("utf-8")).hexdigest()
 
     cache_output("touchpoint_status", sn_key, touchpoint_data)
@@ -300,9 +307,8 @@ async def retrieve_touchpoint_status(
 ):
     """
     Retrieve TouchPointStatus data from the cache for a given user LinkedIn URL
-    and sdr_user_id if available.
+    and agent_id.
     """
-    # ...existing code...
     sn_norm = normalize_linkedin_url(user_linkedin_url.strip())
     sn_key = "touchpoint_status:" + hashlib.sha256((sn_norm.lower() + agent_id).encode("utf-8")).hexdigest()
 
@@ -313,14 +319,16 @@ async def retrieve_connection_status(
     user_linkedin_url: str,
     agent_id: str
 ):
-    # ...existing code...
+    """
+    Retrieve minimal "connection status" from the TouchPointStatus cache.
+    """
     sn_norm = normalize_linkedin_url(user_linkedin_url.strip())
     sn_key = "touchpoint_status:" + hashlib.sha256((sn_norm.lower() + agent_id).encode("utf-8")).hexdigest()
 
     cached_data = retrieve_output("touchpoint_status", sn_key) or {}
     connection_degree = cached_data.get("connection_degree", "")
     connection_status = {
-        "connection_degree": cached_data.get("connection_degree", ""),
+        "connection_degree": connection_degree,
         "connection_request_status": cached_data.get("connection_request_status", ""),
         "is_connected_on_linkedin": connection_degree == "1st"
     }
@@ -332,12 +340,13 @@ async def get_lead_linkedin_messages(user_linkedin_url: str, agent_id: str) -> O
     The cache key includes agent_id in the SHA-256 hash.
     """
     sn_norm = normalize_linkedin_url(user_linkedin_url)
-    sn_key = "salesnav_lead_messages_raw:" + hashlib.sha256((sn_norm + agent_id).encode("utf-8")).hexdigest()
-    list_of_dicts = retrieve_output("lead_linkedin_messages_", sn_key)
-    messages: List[MessageItem] = []
+    sn_key = "salesnav_lead_messages_raw:" + hashlib.sha256(
+        (sn_norm + agent_id).encode("utf-8")
+    ).hexdigest()
 
+    list_of_dicts = retrieve_output("lead_linkedin_messages_", sn_key) or []
+    messages: List[MessageItem] = []
     for message in list_of_dicts:
         message_item = MessageItem(**message)
         messages.append(message_item)
-
     return messages