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

dhisana/utils/check_for_intent_signal.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Optional, cast
 from pydantic import BaseModel
 from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
 from dhisana.utils.compose_search_query import (
-    generate_google_search_queries,
     get_search_results_for_insights
 )
 
@@ -49,7 +48,7 @@ async def check_for_intent_signal(
             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"
-    current_date_iso = datetime.datetime.now().isoformat()
+    datetime.datetime.now().isoformat()
     user_prompt = f"""
     Hi AI Assistant,
     You are an expert in scoring leads based on intent signals.

dhisana/utils/check_linkedin_url_validity.py

@@ -1,6 +1,5 @@
-import os
+import re
 from typing import Dict, List, Optional, Any
-import aiohttp
 from pydantic import BaseModel
 from dhisana.utils.apollo_tools import enrich_person_info_from_apollo
 from dhisana.utils.assistant_tool_tag import assistant_tool
@@ -28,6 +27,7 @@ def compare_field(
     person_key: str
 ) -> bool:
     if not lead_properties.get(lead_key):
+        # If the lead doesn't have the field at all, let's consider it "matched" by default
         return True
 
     lead_value = lead_properties.get(lead_key, "")
@@ -72,8 +72,7 @@ async def validate_linkedin_url_with_apollo(
         linkedin_url=linkedin_url, 
         tool_config=tool_config
     )
-    # If no data is returned from Apollo, return defaults (all False except
-    # the logic in compare_field where no input -> True).
+    # If no data is returned from Apollo, return defaults
     if not linkedin_data:
         return match_result.model_dump()
 
@@ -120,8 +119,7 @@ async def validate_linkedin_url_with_proxy_curl(
         linkedin_url=linkedin_url, 
         tool_config=tool_config
     )
-    # If no data is returned from Apollo, return defaults (all False except
-    # the logic in compare_field where no input -> True).
+    # If no data is returned from Proxycurl, return defaults
     if not linkedin_data:
         return match_result.model_dump()
 
@@ -148,6 +146,18 @@ LINKEDIN_VALIDATE_TOOL_NAME_TO_FUNCTION_MAP = {
     "proxycurl": validate_linkedin_url_with_proxy_curl
 }
 
+def is_proxy_linkedin_url(url: str) -> bool:
+    """
+    Determines if a LinkedIn URL is "proxy-like": 
+    specifically, if /in/<profile_id> starts with 'acw' and is > 10 chars total.
+    """
+    match = re.search(r"linkedin\.com/in/([^/]+)", url, re.IGNORECASE)
+    if match:
+        profile_id = match.group(1).strip()
+        if profile_id.startswith("acw") and len(profile_id) > 10:
+            return True
+    return False
+
 @assistant_tool
 async def check_linkedin_url_validity(
     lead_properties: Dict[str, Any],
@@ -155,10 +165,12 @@ async def check_linkedin_url_validity(
 ) -> Dict[str, bool]:
     """
     Validates LinkedIn URL (and related fields) by choosing the appropriate tool
-    from the tool_config.
+    from the tool_config. If the LinkedIn URL is detected as a "proxy" URL,
+    we skip calling any external tool and directly return 'linkedin_url_valid' = True.
 
     Args:
-        lead_properties (dict): Lead info (e.g. first_name, last_name, job_title, lead_location, user_linkedin_url).
+        lead_properties (dict): Lead info (e.g. first_name, last_name, job_title, 
+                                lead_location, user_linkedin_url).
         tool_config (Optional[List[Dict]]): Configuration to identify which tool is available.
 
     Returns:
@@ -170,6 +182,20 @@ async def check_linkedin_url_validity(
     if not tool_config:
         raise ValueError("No tool configuration found.")
 
+    # ---------------------------------------------------------
+    # 1) If it’s a "proxy" LinkedIn URL, just return valid = True
+    # ---------------------------------------------------------
+    linkedin_url = lead_properties.get("user_linkedin_url", "")
+    if is_proxy_linkedin_url(linkedin_url):
+        match_result = LeadLinkedInMatch()
+        match_result.linkedin_url_valid = True
+        # The other fields remain their default (False) unless
+        # you want to set them otherwise. For now, we just do:
+        return match_result.model_dump()
+
+    # ---------------------------------------------------------
+    # 2) Otherwise, pick the correct tool and validate normally
+    # ---------------------------------------------------------
     chosen_tool_func = None
     for item in tool_config:
         tool_name = item.get("name")

dhisana/utils/clay_tools.py

@@ -1,4 +1,3 @@
-import asyncio
 import aiohttp
 import logging
 from typing import Optional
@@ -22,7 +21,9 @@ async def push_to_clay_table(
     - **dict**: Response message or error.
     """
     if not api_key:
-        return {'error': "API key not provided"}
+        return {
+            'error': "Clay integration is not configured. Please configure the connection to Clay in Integrations."
+        }
 
     if not webhook:
         return {'error': "Webhook URL not provided"}

dhisana/utils/clean_properties.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 import copy
 from typing import Any, Dict, List, Optional
 
+
+
 def remove_empty(data: Any) -> Any:
     """
     Recursively remove empty or null-like values from JSON/dict data.

dhisana/utils/compose_salesnav_query.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from typing import Any, Dict, List, Optional
 
 import openai  # Remove if not required outside get_structured_output_internal

dhisana/utils/compose_search_query.py

@@ -1,4 +1,3 @@
-import datetime
 import logging
 import os
 import json
@@ -352,8 +351,11 @@ async def get_search_results_for_insights(
 
 def get_serp_api_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     """
-    Retrieves the SERPAPI_KEY access token from the provided tool configuration 
+    Retrieves the SERPAPI_KEY access token from the provided tool configuration
     or from the environment variable SERPAPI_KEY.
+
+    Raises:
+        ValueError: If the SerpAPI integration has not been configured.
     """
     serpapi_key = None
     if tool_config:
@@ -373,7 +375,7 @@ def get_serp_api_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     serpapi_key = serpapi_key or os.getenv("SERPAPI_KEY")
     if not serpapi_key:
         raise ValueError(
-            "SERPAPI_KEY access token not found in tool_config or environment variable."
+            "SerpAPI integration is not configured. Please configure the connection to SerpAPI in Integrations."
         )
     return serpapi_key
 
@@ -470,6 +472,7 @@ Output must be valid JSON, e.g.:
         prompt=prompt,
         response_format=TechnologyUsedCheck,
         effort="high",
+        model="gpt-5.1-chat",
         tool_config=tool_config
     )
 
@@ -531,6 +534,7 @@ Output must be valid JSON, e.g.:
         prompt=prompt,
         response_format=TechnologyAndRoleCheck,
         effort="high",
+        model="gpt-5.1-chat",
         tool_config=tool_config
     )
 

dhisana/utils/composite_tools.py

@@ -7,7 +7,6 @@ from dhisana.utils.built_with_api_tools import (
 )
 from dhisana.utils.dataframe_tools import get_structured_output
 from dhisana.utils.google_custom_search import search_google_custom
-from dhisana.utils.serpapi_search_tools import search_google
 
 
 class QualifyCompanyBasedOnTechUsage(BaseModel):

dhisana/utils/dataframe_tools.py

@@ -33,13 +33,13 @@ class PandasQuery(BaseModel):
     
 
 @assistant_tool   
-async def get_structured_output(message: str, response_type, model: str = "o3-mini"):
+async def get_structured_output(message: str, response_type, model: str = "gpt-5.1-chat"):
     """
     Asynchronously retrieves structured output from the OpenAI API based on the input message.
 
     :param message: The input message to be processed by the OpenAI API.
     :param response_type: The expected format of the response (e.g., JSON).
-    :param model: The model to be used for processing the input message. Defaults to "o3-mini".
+    :param model: The model to be used for processing the input message. Defaults to "gpt-5.1-chat".
     :return: A tuple containing the parsed response and a status string ('SUCCESS' or 'FAIL').
     """
     try:

dhisana/utils/email_body_utils.py

@@ -0,0 +1,72 @@
+"""Small helpers for handling e-mail bodies across providers."""
+
+from typing import Optional, Tuple
+import html as html_lib
+import re
+
+
+def looks_like_html(text: str) -> bool:
+    """Heuristically determine whether the body contains HTML markup."""
+    return bool(text and re.search(r"<[a-zA-Z][^>]*>", text))
+
+
+def _normalize_format_hint(format_hint: Optional[str]) -> str:
+    """
+    Normalize a user-supplied format hint into html/text/auto.
+
+    Accepts variations like "plain" or "plaintext" as text.
+    """
+    if not format_hint:
+        return "auto"
+    fmt_raw = getattr(format_hint, "value", format_hint)
+    fmt = str(fmt_raw).strip().lower()
+    if fmt in ("html",):
+        return "html"
+    if fmt in ("text", "plain", "plain_text", "plaintext"):
+        return "text"
+    return "auto"
+
+
+def html_to_plain_text(html: str) -> str:
+    """
+    Produce a very lightweight plain-text version of an HTML fragment.
+    This keeps newlines on block boundaries and strips tags.
+    """
+    if not html:
+        return ""
+    text = re.sub(r"(?is)<(script|style).*?>.*?</\1>", " ", html)
+    text = re.sub(r"(?i)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?i)</(p|div|li|h[1-6])\s*>", "\n", text)
+    text = re.sub(r"(?is)<.*?>", "", text)
+    text = html_lib.unescape(text)
+    text = re.sub(r"\s+\n", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def plain_text_to_html(text: str) -> str:
+    """Wrap plain text in a minimal HTML container that preserves newlines."""
+    if text is None:
+        return ""
+    escaped = html_lib.escape(text)
+    return f'<div style="white-space: pre-wrap">{escaped}</div>'
+
+
+def body_variants(body: Optional[str], format_hint: Optional[str]) -> Tuple[str, str, str]:
+    """
+    Return (plain, html, resolved_format) honoring an optional format hint.
+
+    resolved_format is "html" or "text" after applying auto-detection.
+    """
+    content = body or ""
+    fmt = _normalize_format_hint(format_hint)
+
+    if fmt == "html":
+        return html_to_plain_text(content), content, "html"
+    if fmt == "text":
+        return content, plain_text_to_html(content), "text"
+
+    if looks_like_html(content):
+        return html_to_plain_text(content), content, "html"
+
+    return content, plain_text_to_html(content), "text"

dhisana/utils/email_provider.py

@@ -0,0 +1,375 @@
+# dhisana/email_providers.py
+#
+# Generic e-mail wrapper helpers for Dhisana.
+# ---------------------------------------------------------------
+
+import logging
+from typing import Any, Dict, List, Optional, Sequence
+
+from dhisana.schemas.common import (
+    SendEmailContext,
+    QueryEmailContext,
+    ReplyEmailContext,
+)
+from dhisana.schemas.sales import MessageItem
+from dhisana.utils.google_workspace_tools import (
+    send_email_using_service_account_async,
+    list_emails_in_time_range_async,
+    reply_to_email_async as gw_reply_to_email_async,
+)
+from dhisana.utils.google_oauth_tools import (
+    send_email_using_google_oauth_async,
+    list_emails_in_time_range_google_oauth_async,
+    reply_to_email_google_oauth_async,
+)
+from dhisana.utils.microsoft365_tools import (
+    send_email_using_microsoft_graph_async,
+    list_emails_in_time_range_m365_async,
+    reply_to_email_m365_async,
+)
+from dhisana.utils.smtp_email_tools import (
+    send_email_via_smtp_async,
+    list_emails_in_time_range_imap_async,
+    reply_to_email_via_smtp_async,
+)
+from dhisana.utils.mailgun_tools import send_email_using_mailgun_async
+from dhisana.utils.sendgrid_tools import send_email_using_sendgrid_async
+
+# --------------------------------------------------------------------------- #
+#  Provider-selection helpers
+# --------------------------------------------------------------------------- #
+
+
+def _find_provider_cfg(
+    tool_cfg: Optional[Sequence[Dict]], provider_name: str
+) -> Optional[Dict]:
+    """
+    Return the *first* config-dict whose ``name`` matches *provider_name*.
+    """
+    if not tool_cfg:
+        return None
+    return next((c for c in tool_cfg if c.get("name") == provider_name), None)
+
+
+def _smtp_creds_for_sender(smtp_cfg: Dict, sender_email: str) -> Optional[Dict[str, str]]:
+    """
+    Given an SMTP provider config and a sender address, return the matching
+    ``username`` / ``password`` plus server settings, or ``None``.
+    """
+    try:
+        usernames = [
+            u.strip()
+            for u in next(f for f in smtp_cfg["configuration"] if f["name"] == "usernames")[
+                "value"
+            ].split(",")
+            if u.strip()
+        ]
+        passwords = [
+            p.strip()
+            for p in next(f for f in smtp_cfg["configuration"] if f["name"] == "passwords")[
+                "value"
+            ].split(",")
+        ]
+        if len(usernames) != len(passwords):
+            logging.warning(
+                "smtpEmail config: usernames/passwords length mismatch – skipping"
+            )
+            return None
+
+        if sender_email not in usernames:
+            return None
+
+        idx = usernames.index(sender_email)
+
+        def _field(name: str, default):
+            try:
+                return next(f for f in smtp_cfg["configuration"] if f["name"] == name)[
+                    "value"
+                ]
+            except StopIteration:
+                return default
+
+        return {
+            "username": usernames[idx],
+            "password": passwords[idx],
+            "smtp_host": _field("smtpEndpoint", "smtp.gmail.com"),
+            "smtp_port": int(_field("smtpPort", 587)),
+            "imap_host": _field("imapEndpoint", "imap.gmail.com"),
+            "imap_port": int(_field("imapPort", 993)),
+        }
+    except Exception:
+        logging.exception("Failed to parse smtpEmail config")
+        return None
+
+
+# --------------------------------------------------------------------------- #
+#  Public wrapper APIs
+# --------------------------------------------------------------------------- #
+
+async def send_email_async(
+    send_email_context: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = (
+        "mailgun",
+        "sendgrid",
+        "google",          # Google OAuth (per-user token)
+        "smtpEmail",
+        "googleworkspace", # Google Workspace service account (DWD)
+        "microsoft365",
+    ),
+):
+    """
+    Send an e-mail using the first *configured* provider in *provider_order*.
+
+    Returns whatever the underlying provider helper returns:
+
+        * SMTP              → str                (Message-ID)
+        * Microsoft 365     → str                (message-id)
+        * Google Workspace  → str                (message-id)
+    """
+    # ------------------------------------------------------------------ #
+    # 1) Try the preferred providers in order
+    # ------------------------------------------------------------------ #
+    for provider in provider_order:
+        # 1a) SMTP
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, send_email_context.sender_email)
+            if not creds:
+                # No creds for this sender – fall through.
+                continue
+
+            return await send_email_via_smtp_async(
+                send_email_context,
+                smtp_server=creds["smtp_host"],
+                smtp_port=creds["smtp_port"],
+                username=creds["username"],
+                password=creds["password"],
+                use_starttls=(creds["smtp_port"] == 587),
+            )
+
+        # 1b) Mailgun
+        elif provider == "mailgun":
+            mg_cfg = _find_provider_cfg(tool_config, "mailgun")
+            if not mg_cfg:
+                continue
+            return await send_email_using_mailgun_async(send_email_context, tool_config)
+
+        # 1c) SendGrid
+        elif provider == "sendgrid":
+            sg_cfg = _find_provider_cfg(tool_config, "sendgrid")
+            if not sg_cfg:
+                continue
+            return await send_email_using_sendgrid_async(send_email_context, tool_config)
+
+        # 1d) Google (Gmail API via per-user OAuth)
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+            return await send_email_using_google_oauth_async(send_email_context, tool_config)
+
+        # 1e) Google Workspace
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+
+            return await send_email_using_service_account_async(
+                send_email_context, tool_config
+            )
+
+        # 1f) Microsoft 365 (Graph API)
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+
+            return await send_email_using_microsoft_graph_async(
+                send_email_context, tool_config
+            )
+
+        # -- future providers slot --------------------------------------
+
+    # ------------------------------------------------------------------ #
+    # 2) FINAL FALLBACK — use *first* SMTP credentials if available
+    # ------------------------------------------------------------------ #
+    smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+    if smtp_cfg:
+        try:
+            usernames = [
+                u.strip()
+                for u in next(
+                    f for f in smtp_cfg["configuration"] if f["name"] == "usernames"
+                )["value"].split(",")
+                if u.strip()
+            ]
+            passwords = [
+                p.strip()
+                for p in next(
+                    f for f in smtp_cfg["configuration"] if f["name"] == "passwords"
+                )["value"].split(",")
+            ]
+            if usernames and len(usernames) == len(passwords):
+                # Build a fake SendEmailContext for the fallback user, so that
+                # the underlying SMTP helper still sends the intended message
+                # but authenticates with the first available mailbox.
+                fallback_sender = usernames[0]
+                creds = _smtp_creds_for_sender(smtp_cfg, fallback_sender)
+
+                if creds:
+                    logging.info(
+                        "Fallback: no provider matched – using first SMTP creds (%s).",
+                        creds["username"],
+                    )
+                    return await send_email_via_smtp_async(
+                        send_email_context,
+                        smtp_server=creds["smtp_host"],
+                        smtp_port=creds["smtp_port"],
+                        username=creds["username"],
+                        password=creds["password"],
+                        use_starttls=(creds["smtp_port"] == 587),
+                    )
+        except Exception:
+            logging.exception("SMTP fallback failed")
+
+    # ------------------------------------------------------------------ #
+    # 3) Nothing worked
+    # ------------------------------------------------------------------ #
+    raise RuntimeError("No suitable e-mail provider configured for this sender.")
+
+
+
+
+async def list_emails_async(
+    query_email_context: QueryEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
+) -> List[MessageItem]:
+    """
+    List e-mails (see ``QueryEmailContext``) using the first configured provider.
+
+    Always returns ``List[MessageItem]``.
+    """
+    for provider in provider_order:
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, query_email_context.sender_email)
+            if not creds:
+                continue
+
+            return await list_emails_in_time_range_imap_async(
+                query_email_context,
+                imap_server=creds["imap_host"],
+                imap_port=creds["imap_port"],
+                username=creds["username"],
+                password=creds["password"],
+            )
+
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+            return await list_emails_in_time_range_google_oauth_async(query_email_context, tool_config)
+
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+            return await list_emails_in_time_range_async(query_email_context, tool_config)
+
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+            return await list_emails_in_time_range_m365_async(query_email_context, tool_config)
+
+        # --- future providers go here ---
+
+    logging.warning(
+        "No suitable inbox provider configured for sender %s; returning empty list.",
+        query_email_context.sender_email,
+    )
+    return []
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# New public helper: reply_email_async
+# ─────────────────────────────────────────────────────────────────────────────
+async def reply_email_async(
+    reply_email_context: ReplyEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
+) -> Dict[str, Any]:
+    """
+    Reply (reply-all) to an e-mail using the first *configured* provider
+    in *provider_order*.
+
+    Returns the provider’s reply-metadata dictionary.
+    """
+    for provider in provider_order:
+        # ------------------------------------------------------------------
+        # 1) SMTP
+        # ------------------------------------------------------------------
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, reply_email_context.sender_email)
+            if not creds:
+                continue
+
+            return await reply_to_email_via_smtp_async(
+                reply_email_context,
+                smtp_server=creds["smtp_host"],
+                smtp_port=creds["smtp_port"],
+                imap_server=creds["imap_host"],
+                imap_port=creds["imap_port"],
+                username=creds["username"],
+                password=creds["password"],
+                use_starttls_smtp=(creds["smtp_port"] == 587),
+            )
+
+        # ------------------------------------------------------------------
+        # 2) Google OAuth (per-user)
+        # ------------------------------------------------------------------
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+
+            return await reply_to_email_google_oauth_async(reply_email_context, tool_config)
+
+        # ------------------------------------------------------------------
+        # 3) Google Workspace service-account
+        # ------------------------------------------------------------------
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+
+            return await gw_reply_to_email_async(reply_email_context, tool_config)
+
+        # ------------------------------------------------------------------
+        # 4) Microsoft 365 (Graph)
+        # ------------------------------------------------------------------
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+
+            return await reply_to_email_m365_async(reply_email_context, tool_config)
+
+        # -- future providers slot -----------------------------------------
+
+    raise RuntimeError("No suitable reply-capable e-mail provider configured.")