dhisana 0.0.1.dev233__py3-none-any.whl → 0.0.1.dev235__py3-none-any.whl

dhisana/schemas/common.py

@@ -392,6 +392,7 @@ class ReplyEmailContext(BaseModel):
     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/utils/google_oauth_tools.py

@@ -267,15 +267,45 @@ async def reply_to_email_google_oauth_async(
             _rethrow_with_google_message(exc, "Gmail Fetch Message OAuth")
 
     headers_list = (original.get("payload") or {}).get("headers", [])
-    headers_map = {h.get("name"): h.get("value") for h in headers_list if isinstance(h, dict)}
-    thread_id = original.get("threadId")
-
-    subject = headers_map.get("Subject", "") or ""
+    # Use case-insensitive lookups via find_header to avoid missing values on header casing differences.
+    subject = find_header(headers_list, "Subject") or ""
     if not subject.startswith("Re:"):
         subject = f"Re: {subject}"
-    to_addresses = headers_map.get("From", "") or ""
-    cc_addresses = headers_map.get("Cc", "") or ""
-    message_id_header = headers_map.get("Message-ID", "") or ""
+    reply_to_header = find_header(headers_list, "Reply-To") or ""
+    from_header = find_header(headers_list, "From") or ""
+    to_header = find_header(headers_list, "To") or ""
+    cc_header = find_header(headers_list, "Cc") or ""
+    message_id_header = find_header(headers_list, "Message-ID") or ""
+    thread_id = original.get("threadId")
+
+    sender_email_lc = (reply_email_context.sender_email or "").lower()
+
+    def _is_self(addr: str) -> bool:
+        return bool(sender_email_lc) and sender_email_lc in addr.lower()
+
+    cc_addresses = cc_header or ""
+    # Prefer Reply-To unless it points back to the sender. If the original was SENT mail,
+    # From will equal the sender, so we should reply to the original To/CC instead.
+    if reply_to_header and not _is_self(reply_to_header):
+        to_addresses = reply_to_header
+    elif from_header and not _is_self(from_header):
+        to_addresses = from_header
+    elif to_header and not _is_self(to_header):
+        to_addresses = to_header
+    else:
+        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+        to_addresses = combined
+        cc_addresses = ""
+
+    if (not to_addresses or _is_self(to_addresses)) and reply_email_context.fallback_recipient:
+        if not _is_self(reply_email_context.fallback_recipient):
+            to_addresses = reply_email_context.fallback_recipient
+            cc_addresses = ""
+
+    if not to_addresses or _is_self(to_addresses):
+        raise ValueError(
+            "No valid recipient found in the original message; refusing to reply to sender."
+        )
 
     # 2) Build reply MIME
     plain_reply, html_reply, resolved_reply_fmt = body_variants(

dhisana/utils/google_workspace_tools.py

@@ -895,17 +895,43 @@ async def reply_to_email_async(
         original_message = response.json()
 
     headers_list = original_message.get('payload', {}).get('headers', [])
-    headers_dict = {h['name']: h['value'] for h in headers_list}
-    thread_id = original_message.get('threadId')
-
-    # 2. Prepare reply headers
-    subject = headers_dict.get('Subject', '')
+    # Case-insensitive header lookup and resilient recipient fallback to avoid Gmail 400s.
+    subject = find_header(headers_list, 'Subject') or ''
     if not subject.startswith('Re:'):
         subject = f'Re: {subject}'
+    reply_to_header = find_header(headers_list, 'Reply-To') or ''
+    from_header = find_header(headers_list, 'From') or ''
+    to_header = find_header(headers_list, 'To') or ''
+    cc_header = find_header(headers_list, 'Cc') or ''
+    message_id_header = find_header(headers_list, 'Message-ID') or ''
+    thread_id = original_message.get('threadId')
+
+    sender_email_lc = (reply_email_context.sender_email or '').lower()
+
+    def _is_self(addr: str) -> bool:
+        return bool(sender_email_lc) and sender_email_lc in addr.lower()
 
-    to_addresses = headers_dict.get('From', '')
-    cc_addresses = headers_dict.get('Cc', '')
-    message_id_header = headers_dict.get('Message-ID', '')
+    cc_addresses = cc_header or ''
+    if reply_to_header and not _is_self(reply_to_header):
+        to_addresses = reply_to_header
+    elif from_header and not _is_self(from_header):
+        to_addresses = from_header
+    elif to_header and not _is_self(to_header):
+        to_addresses = to_header
+    else:
+        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+        to_addresses = combined
+        cc_addresses = ''
+
+    if (not to_addresses or _is_self(to_addresses)) and reply_email_context.fallback_recipient:
+        if not _is_self(reply_email_context.fallback_recipient):
+            to_addresses = reply_email_context.fallback_recipient
+            cc_addresses = ''
+
+    if not to_addresses or _is_self(to_addresses):
+        raise ValueError(
+            "No valid recipient found in the original message; refusing to reply to sender."
+        )
 
     # 3. Create the reply email message
     plain_reply, html_reply, resolved_reply_fmt = body_variants(

dhisana/utils/microsoft365_tools.py

@@ -351,10 +351,50 @@ async def reply_to_email_m365_async(
         orig_subject = orig.get("subject", "")
         subject = orig_subject if orig_subject.startswith("Re:") else f"Re: {orig_subject}"
         thread_id = orig.get("conversationId", "")
-        from_addr = orig.get("from", {}).get("emailAddress", {})
-        to_addresses = from_addr.get("address", "")
         cc_list = orig.get("ccRecipients", [])
-        cc_addresses = ", ".join([(r.get("emailAddress", {}) or {}).get("address", "") for r in cc_list if r])
+        to_list = orig.get("toRecipients", [])
+        sender_email_lc = (reply_email_context.sender_email or "").lower()
+
+        def _is_self(addr: str) -> bool:
+            return bool(sender_email_lc) and sender_email_lc in addr.lower()
+
+        def _addresses(recipients: List[Dict[str, Any]]) -> List[str]:
+            return [
+                (recipient.get("emailAddress", {}) or {}).get("address", "")
+                for recipient in recipients
+                if recipient
+            ]
+
+        to_addresses = ", ".join(
+            [addr for addr in _addresses(to_list) if addr and not _is_self(addr)]
+        )
+        cc_addresses = ", ".join(
+            [addr for addr in _addresses(cc_list) if addr and not _is_self(addr)]
+        )
+
+        all_recipients = [addr for addr in _addresses(to_list + cc_list) if addr]
+        if not any(all_recipients):
+            from_addr = orig.get("from", {}).get("emailAddress", {})
+            from_address = from_addr.get("address", "")
+            if from_address:
+                all_recipients.append(from_address)
+
+        non_self_recipients = [addr for addr in all_recipients if not _is_self(addr)]
+        if not non_self_recipients and reply_email_context.fallback_recipient:
+            fr = reply_email_context.fallback_recipient
+            if fr and not _is_self(fr):
+                non_self_recipients.append(fr)
+
+        if not to_addresses and non_self_recipients:
+            to_addresses = ", ".join(non_self_recipients)
+            cc_addresses = ""
+
+        if not non_self_recipients:
+            raise httpx.HTTPStatusError(
+                "No valid recipient found in the original message; refusing to reply to sender.",
+                request=get_resp.request,
+                response=get_resp,
+            )
 
         # 2) Create reply-all draft with comment
         create_reply_url = (

dhisana/utils/smtp_email_tools.py

@@ -394,17 +394,99 @@ async def reply_to_email_via_smtp_async(
         )
         try:
             conn.login(username, password)
-            conn.select(mailbox, readonly=False)  # can set flags if needed
-            # Search for the exact Message-ID header
-            status, nums = conn.search(None, "HEADER", "Message-ID", ctx.message_id)
-            if status != "OK" or not nums[0]:
-                logging.warning("IMAP search for %r returned %s", ctx.message_id, nums)
+            # Sent messages usually live outside INBOX; build a candidate list
+            # from the provided mailbox, common sent folders, and any LISTed
+            # mailboxes containing "sent" (case-insensitive).
+            candidate_mailboxes = []
+            if mailbox:
+                candidate_mailboxes.append(mailbox)
+            candidate_mailboxes.extend([
+                "Sent",
+                "Sent Items",
+                "Sent Mail",
+                "[Gmail]/Sent Mail",
+                "[Gmail]/Sent Items",
+                "INBOX.Sent",
+                "INBOX/Sent",
+            ])
+            try:
+                status, mailboxes = conn.list()
+                if status == "OK" and mailboxes:
+                    for mbox in mailboxes:
+                        try:
+                            decoded = mbox.decode(errors="ignore")
+                        except Exception:
+                            decoded = str(mbox)
+                        # Parse flags + name from LIST response:
+                        # e.g., (\\HasNoChildren \\Sent) "/" "Sent Items"
+                        flags = set()
+                        name_part = decoded
+                        if ") " in decoded:
+                            flags_raw, _, remainder = decoded.partition(") ")
+                            flags = {f.lower() for f in flags_raw.strip("(").split() if f}
+                            # remainder is like '"/" "Sent Items"' or '"/" Sent'
+                            pieces = remainder.split(" ", 1)
+                            if len(pieces) == 2:
+                                name_part = pieces[1].strip()
+                            else:
+                                name_part = remainder.strip()
+                        name_part = name_part.strip()
+                        if name_part.startswith('"') and name_part.endswith('"'):
+                            name_part = name_part[1:-1]
+
+                        # Prefer provider-marked \Sent flag; otherwise fall back to substring match.
+                        is_sent_flag = "\\sent" in flags
+                        is_sent_name = "sent" in name_part.lower()
+                        if is_sent_flag or is_sent_name:
+                            candidate_mailboxes.append(name_part)
+            except Exception:
+                logging.exception("IMAP LIST failed; continuing with default sent folders")
+            # Deduplicate while preserving order
+            seen = set()
+            candidate_mailboxes = [m for m in candidate_mailboxes if not (m in seen or seen.add(m))]
+
+            msg_data = None
+            for mb in candidate_mailboxes:
+                def _try_select(name: str) -> bool:
+                    # Quote mailbox names with spaces or special chars; fall back to raw.
+                    for candidate in (f'"{name}"', name):
+                        try:
+                            status, _ = conn.select(candidate, readonly=False)
+                        except imaplib.IMAP4.error as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        except Exception as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        if status == "OK":
+                            return True
+                    return False
+
+                if not _try_select(mb):
+                    continue
+                # Search for the Message-ID header. Some servers store IDs without angle
+                # brackets or require quoted search terms, so try a few variants.
+                candidates = [ctx.message_id]
+                trimmed = ctx.message_id.strip()
+                if trimmed.startswith("<") and trimmed.endswith(">"):
+                    candidates.append(trimmed[1:-1])
+                for mid in candidates:
+                    status, nums = conn.search(None, "HEADER", "Message-ID", f'"{mid}"')
+                    if status == "OK" and nums and nums[0]:
+                        num = nums[0].split()[0]
+                        _, data = conn.fetch(num, "(RFC822)")
+                        if ctx.mark_as_read.lower() == "true":
+                            conn.store(num, "+FLAGS", "\\Seen")
+                        msg_data = data[0][1] if data and data[0] else None
+                        break
+                if msg_data:
+                    break
+
+            if not msg_data:
+                logging.warning("IMAP search for %r returned no matches in any mailbox", ctx.message_id)
                 return None
-            num = nums[0].split()[0]
-            _, data = conn.fetch(num, "(RFC822)")
-            if ctx.mark_as_read.lower() == "true":
-                conn.store(num, "+FLAGS", "\\Seen")
-            return data[0][1] if data and data[0] else None
+
+            return msg_data
         finally:
             try:
                 conn.close()
@@ -422,6 +504,17 @@ async def reply_to_email_via_smtp_async(
     # 2. Derive reply headers
     to_addrs = hdr("Reply-To") or hdr("From")
     cc_addrs = hdr("Cc")
+    # If the derived recipient points back to the sender or is missing, fall back to provided recipient.
+    sender_email_lc = (ctx.sender_email or "").lower()
+    def _is_self(addr: str) -> bool:
+        return bool(sender_email_lc) and sender_email_lc in addr.lower()
+    if (not to_addrs or _is_self(to_addrs)) and getattr(ctx, "fallback_recipient", None):
+        fr = ctx.fallback_recipient
+        if fr and not _is_self(fr):
+            to_addrs = fr
+            cc_addrs = ""
+    if not to_addrs or _is_self(to_addrs):
+        raise RuntimeError("No valid recipient found in original message; refusing to reply to sender.")
     subject = hdr("Subject")
     if not subject.lower().startswith("re:"):
         subject = f"Re: {subject}"

dhisana/utils/test_connect.py

@@ -1263,6 +1263,41 @@ async def test_firecrawl(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(exc)}
 
 
+async def test_scraperapi(api_key: str) -> Dict[str, Any]:
+    """Connectivity check for ScraperAPI using a simple NYTimes scrape."""
+    url = "https://api.scraperapi.com/"
+    params = {
+        "api_key": api_key,
+        "url": "https://example.com/",  # lightweight public page to minimize credit usage
+        "output_format": "markdown",
+    }
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, params=params) as response:
+                status = response.status
+                body_text = await response.text()
+
+                if status != 200:
+                    snippet = body_text[:200] if body_text else None
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": snippet or f"Non-200 from ScraperAPI: {status}",
+                    }
+
+                if not body_text:
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": "ScraperAPI returned an empty response.",
+                    }
+
+                return {"success": True, "status_code": status, "error_message": None}
+    except Exception as exc:
+        logger.error(f"ScraperAPI connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
 async def test_youtube(api_key: str) -> Dict[str, Any]:
     """
     Tests YouTube Data API v3 by making a simple search request.
@@ -1341,6 +1376,276 @@ async def test_youtube(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(exc)}
 
 
+async def test_orum(api_key: str) -> Dict[str, Any]:
+    """
+    Validate an Orum API key by calling a lightweight authenticated endpoint.
+
+    The base URL can be overridden with ORUM_API_BASE_URL if needed.
+    """
+    base_url = os.getenv("ORUM_API_BASE_URL", "https://api.orum.com")
+    url = f"{base_url.rstrip('/')}/api/v1/users/me"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Orum responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Orum connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_aircall(app_id: str, api_token: str) -> Dict[str, Any]:
+    """
+    Validate Aircall credentials via a lightweight authenticated call.
+    Uses HTTP Basic Auth (app_id:api_token).
+    """
+    url = "https://api.aircall.io/v1/users"
+    params = {"per_page": 1}
+
+    try:
+        auth = aiohttp.BasicAuth(app_id, api_token)
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10), auth=auth) as session:
+            async with session.get(url, params=params) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200 and isinstance(data, dict) and "users" in data:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Aircall responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Aircall connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_ringover(api_key: str) -> Dict[str, Any]:
+    """
+    Validate Ringover API key using a minimal authenticated request.
+    """
+    base_url = os.getenv("RINGOVER_API_BASE_URL", "https://public-api.ringover.com")
+    url = f"{base_url.rstrip('/')}/v2/users"
+    headers = {
+        "X-API-KEY": api_key,
+        "Accept": "application/json",
+    }
+    params = {"limit": 1}
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers, params=params) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Ringover responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Ringover connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_dialpad(client_id: str, client_secret: str) -> Dict[str, Any]:
+    """
+    Validate Dialpad client credentials via client_credentials token exchange, then whoami.
+    """
+    base_url = os.getenv("DIALPAD_API_BASE_URL", "https://dialpad.com")
+    token_url = f"{base_url.rstrip('/')}/oauth/token"
+    whoami_url = f"{base_url.rstrip('/')}/api/v2/whoami"
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            token_resp = await session.post(
+                token_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                },
+                headers={"Accept": "application/json"},
+            )
+            token_status = token_resp.status
+            token_data = await safe_json(token_resp)
+
+            access_token = None
+            if isinstance(token_data, dict):
+                access_token = token_data.get("access_token")
+
+            if token_status != 200 or not access_token:
+                message = None
+                if isinstance(token_data, dict):
+                    message = token_data.get("error_description") or token_data.get("error")
+                return {
+                    "success": False,
+                    "status_code": token_status,
+                    "error_message": message or "Failed to obtain Dialpad access token.",
+                }
+
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+            }
+            async with session.get(whoami_url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Dialpad responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Dialpad connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_nooks(api_key: str) -> Dict[str, Any]:
+    """
+    Validate Nooks.ai API key via a simple authenticated call.
+    """
+    base_url = os.getenv("NOOKS_API_BASE_URL", "https://api.nooks.ai")
+    url = f"{base_url.rstrip('/')}/v1/users/me"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Nooks.ai responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Nooks.ai connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_commonroom(api_key: str) -> Dict[str, Any]:
+    """Validate a Common Room API token via the token status endpoint."""
+    url = "https://api.commonroom.io/community/v1/api-token-status"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = (
+                        data.get("message")
+                        or data.get("reason")
+                        or data.get("error")
+                        or data.get("docs")
+                    )
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Common Room responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Common Room connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_scarf(api_key: str) -> Dict[str, Any]:
+    """
+    Validate a Scarf API token via the lightweight /v2/search endpoint.
+
+    The endpoint requires only the bearer token and a simple query string.
+    """
+    url = "https://api.scarf.sh/v2/search"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {"query": "dhisana connectivity test"}
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.post(url, headers=headers, json=payload) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status != 200:
+                    message = None
+                    if isinstance(data, dict):
+                        message = data.get("message") or data.get("error") or data.get("detail")
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": message or f"Scarf responded with {status}",
+                    }
+
+                if isinstance(data, dict) and "results" in data:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": "Unexpected Scarf response payload.",
+                }
+    except Exception as exc:
+        logger.error(f"Scarf connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
 ###############################################################################
 #                              DATAGMA CONNECTIVITY
 ###############################################################################
@@ -1427,6 +1732,13 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "firefliesai":      test_firefliesai,
         "firecrawl":        test_firecrawl,
         "youtube":          test_youtube,
+        "orum":             test_orum,
+        "aircall":          test_aircall,   # handled specially to pass appId + apiToken
+        "ringover":         test_ringover,
+        "dialpad":          test_dialpad,   # handled specially to pass client credentials
+        "nooks":            test_nooks,
+        "commonRoom":       test_commonroom,
+        "scarf":            test_scarf,
         "salesforce":       test_salesforce,
         "clay":             test_clay,
         "posthog":          test_posthog,
@@ -1435,6 +1747,7 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "mailgun":          test_mailgun,
         "sendgrid":         test_sendgrid,
         "samgov":          test_samgov,
+        "scraperapi":       test_scraperapi,
     }
 
     results: Dict[str, Dict[str, Any]] = {}
@@ -1603,6 +1916,40 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
                 )
             continue
 
+        # ------------------------------------------------------------------ #
+        # Special-case: Aircall (app_id + api_token)
+        # ------------------------------------------------------------------ #
+        if tool_name == "aircall":
+            app_id = next((c["value"] for c in config_entries if c["name"] == "apiId"), None)
+            api_token = next((c["value"] for c in config_entries if c["name"] == "apiToken"), None)
+            if not app_id or not api_token:
+                results[tool_name] = {
+                    "success": False,
+                    "status_code": 0,
+                    "error_message": "Missing apiId or apiToken for Aircall.",
+                }
+            else:
+                logger.info("Testing connectivity for Aircall…")
+                results[tool_name] = await test_aircall(app_id, api_token)
+            continue
+
+        # ------------------------------------------------------------------ #
+        # Special-case: Dialpad (client credentials)
+        # ------------------------------------------------------------------ #
+        if tool_name == "dialpad":
+            client_id = next((c["value"] for c in config_entries if c["name"] == "clientId"), None)
+            client_secret = next((c["value"] for c in config_entries if c["name"] == "clientSecret"), None)
+            if not client_id or not client_secret:
+                results[tool_name] = {
+                    "success": False,
+                    "status_code": 0,
+                    "error_message": "Missing clientId or clientSecret for Dialpad.",
+                }
+            else:
+                logger.info("Testing connectivity for Dialpad…")
+                results[tool_name] = await test_dialpad(client_id, client_secret)
+            continue
+
         # ------------------------------------------------------------------ #
         # All other tools – expect an apiKey by default
         # ------------------------------------------------------------------ #

{dhisana-0.0.1.dev233.dist-info → dhisana-0.0.1.dev235.dist-info}/METADATA

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

{dhisana-0.0.1.dev233.dist-info → dhisana-0.0.1.dev235.dist-info}/RECORD

@@ -5,7 +5,7 @@ dhisana/cli/datasets.py,sha256=OwzoCrVQqmh0pKpUAKAg_w9uGYncbWU7ZrAL_QukxAk,839
 dhisana/cli/models.py,sha256=IzUFZW_X32mL3fpM1_j4q8AF7v5nrxJcxBoqvG-TTgA,706
 dhisana/cli/predictions.py,sha256=VYgoLK1Ksv6MFImoYZqjQJkds7e5Hso65dHwbxTNNzE,646
 dhisana/schemas/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
-dhisana/schemas/common.py,sha256=SI6nldyfvZhNhfJwy2Qo1VJ7xwuAlg4QHYGLWPoVvZo,9287
+dhisana/schemas/common.py,sha256=rt1ho4nzVhTwTQ_1Kx5TI-xZSbnyDpYN0fQ8Fgf8z6k,9332
 dhisana/schemas/sales.py,sha256=k-ZTB-DaQbjvI882L6443H4gspWBFY-VrY2_1xlLn74,33587
 dhisana/ui/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
 dhisana/ui/components.py,sha256=4NXrAyl9tx2wWwoVYyABO-EOGnreGMvql1AkXWajIIo,14316
@@ -46,15 +46,15 @@ dhisana/utils/generate_linkedin_connect_message.py,sha256=WZThEun-DMuAOqlzMI--hG
 dhisana/utils/generate_linkedin_response_message.py,sha256=-jg-u5Ipf4-cn9q0yjEHsEBe1eJhYLCLrjZDtOXnCyQ,14464
 dhisana/utils/generate_structured_output_internal.py,sha256=DmZ5QzW-79Jo3JL5nDCZQ-Fjl8Nz7FHK6S0rZxXbKyg,20705
 dhisana/utils/google_custom_search.py,sha256=5rQ4uAF-hjFpd9ooJkd6CjRvSmhZHhqM0jfHItsbpzk,10071
-dhisana/utils/google_oauth_tools.py,sha256=pN5YGkM50OieCFpz9RlmEwfrnGzkh342e0h5XschuuE,26211
-dhisana/utils/google_workspace_tools.py,sha256=wyBy5WN3-eUCrKz1HYr_CS0vdsiQgOA-SFb368jSDrY,46957
+dhisana/utils/google_oauth_tools.py,sha256=sxWZLHMfFSF4Wyu-FxQKQiDKDHe0Kl_rRk7D6ejBLYg,27609
+dhisana/utils/google_workspace_tools.py,sha256=pvO1rtDpknHAO9bmBKJ9Zhvrv65Og3U2x20W1ytql08,48185
 dhisana/utils/hubspot_clearbit.py,sha256=keNX1F_RnDl9AOPxYEOTMdukV_A9g8v9j1fZyT4tuP4,3440
 dhisana/utils/hubspot_crm_tools.py,sha256=lbXFCeq690_TDLjDG8Gm5E-2f1P5EuDqNf5j8PYpMm8,99298
 dhisana/utils/instantly_tools.py,sha256=hhqjDPyLE6o0dzzuvryszbK3ipnoGU2eBm6NlsUGJjY,4771
 dhisana/utils/linkedin_crawler.py,sha256=6fMQTY5lTw2kc65SFHgOAM6YfezAS0Yhg-jkiX8LGHo,6533
 dhisana/utils/lusha_tools.py,sha256=MdiWlxBBjSNpSKz8rhNOyLPtbeh-YWHgGiUq54vN_gM,12734
 dhisana/utils/mailgun_tools.py,sha256=qUD-jFMZpmkkkKtyihVSe9tgFzYe-UiiBDHQKtsLq0M,5284
-dhisana/utils/microsoft365_tools.py,sha256=AwWSdE-xeHkCx9T_cVgDbzBmsz7Co4KE45rAmt_lnAc,16723
+dhisana/utils/microsoft365_tools.py,sha256=aNIUBBz56HhvnEd0ZMy5EGAtsXcBJ_VOMO5Yy4dyojQ,18289
 dhisana/utils/openai_assistant_and_file_utils.py,sha256=-eyPcxFvtS-DDtYQGle1SU6C6CuxjulVIojFy27HeWc,8957
 dhisana/utils/openai_helpers.py,sha256=ZK9S5-jcLCpiiD6XBLkCqYcNz-AGYmO9xh4e2H-FDLo,40155
 dhisana/utils/openapi_spec_to_tools.py,sha256=oBLVq3WeDWvW9O02NCvY8bxQURQdKwHJHGcX8bC_b2I,1926
@@ -78,8 +78,8 @@ dhisana/utils/serpapi_search_tools.py,sha256=xiiYi6Rd6Mqn94mjSKEs5nNZk1l2-PW_hTL
 dhisana/utils/serperdev_google_jobs.py,sha256=m5_2f_5y79FOFZz1A_go6m0hIUfbbAoZ0YTjUMO2BSI,4508
 dhisana/utils/serperdev_local_business.py,sha256=JoZfTg58Hojv61cyuwA2lcnPdLT1lawnWaBNrUYWnuQ,6447
 dhisana/utils/serperdev_search.py,sha256=_iBKIfHMq4gFv5StYz58eArriygoi1zW6VnLlux8vto,9363
-dhisana/utils/smtp_email_tools.py,sha256=tF6GoNqkS9pWP52VTTrYSgL7wPdIp3XTklxrHLdzU5o,17186
-dhisana/utils/test_connect.py,sha256=MSF0x_bZm9xL5rQixIFXaB1L7x9SIhtdhT5wMeQM_aA,69087
+dhisana/utils/smtp_email_tools.py,sha256=_1FoN6e-rgkjAKnCVym_IvihJFKz_dOo-43iM6CVqhA,21855
+dhisana/utils/test_connect.py,sha256=aQjPIKevMF_c-wd4Te2UtPpaY-dEa9PVp6MsNCjQ7q8,83667
 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
@@ -93,8 +93,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.dev233.dist-info/METADATA,sha256=9WZyBULJfdKuyYQQCJ6-H3PbFp51F_mkgjtWvpD4UIU,1190
-dhisana-0.0.1.dev233.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dhisana-0.0.1.dev233.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
-dhisana-0.0.1.dev233.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
-dhisana-0.0.1.dev233.dist-info/RECORD,,
+dhisana-0.0.1.dev235.dist-info/METADATA,sha256=FUmdIhxgFjRKEpg8NjqFPuJOVkVhuEi0GcEn47hztGU,1190
+dhisana-0.0.1.dev235.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dhisana-0.0.1.dev235.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
+dhisana-0.0.1.dev235.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
+dhisana-0.0.1.dev235.dist-info/RECORD,,