dhisana 0.0.1.dev227__tar.gz → 0.0.1.dev228__tar.gz

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/PKG-INFO

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

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/setup.py

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

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/schemas/common.py

@@ -364,6 +364,12 @@ 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
@@ -371,6 +377,7 @@ class SendEmailContext(BaseModel):
     sender_name: str
     sender_email: str
     labels: Optional[List[str]]
+    body_format: BodyFormat = BodyFormat.AUTO
     
 class QueryEmailContext(BaseModel):
     start_time: str
@@ -386,4 +393,5 @@ class ReplyEmailContext(BaseModel):
     sender_email: str
     sender_name: str
     mark_as_read: str = "True"
-    add_labels: Optional[List[str]] = None
+    add_labels: Optional[List[str]] = None
+    reply_body_format: BodyFormat = BodyFormat.AUTO

dhisana-0.0.1.dev228/src/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-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/google_oauth_tools.py

@@ -2,6 +2,7 @@ import base64
 import json
 import logging
 import re
+from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Any, Dict, List, Optional
 
@@ -22,6 +23,7 @@ from dhisana.utils.email_parse_helpers import (
 )
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.cache_output_tools import retrieve_output, cache_output
+from dhisana.utils.email_body_utils import body_variants
 from typing import Optional as _Optional  # avoid name clash in wrappers
 
 def _status_phrase(code: int) -> str:
@@ -127,7 +129,18 @@ async def send_email_using_google_oauth_async(
     """
     token = get_google_access_token(tool_config)
 
-    message = MIMEText(send_email_context.body, _subtype="html")
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+    # Use multipart/alternative when we have both; fall back to single part for pure text.
+    if resolved_fmt == "text":
+        message = MIMEText(plain_body, "plain", _charset="utf-8")
+    else:
+        message = MIMEMultipart("alternative")
+        message.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        message.attach(MIMEText(html_body, "html", _charset="utf-8"))
+
     message["to"] = send_email_context.recipient
     message["from"] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message["subject"] = send_email_context.subject
@@ -265,7 +278,17 @@ async def reply_to_email_google_oauth_async(
     message_id_header = headers_map.get("Message-ID", "") or ""
 
     # 2) Build reply MIME
-    msg = MIMEText(reply_email_context.reply_body, _subtype="html")
+    plain_reply, html_reply, resolved_reply_fmt = body_variants(
+        reply_email_context.reply_body,
+        getattr(reply_email_context, "reply_body_format", None),
+    )
+    if resolved_reply_fmt == "text":
+        msg = MIMEText(plain_reply, "plain", _charset="utf-8")
+    else:
+        msg = MIMEMultipart("alternative")
+        msg.attach(MIMEText(plain_reply, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_reply, "html", _charset="utf-8"))
+
     msg["To"] = to_addresses
     if cc_addresses:
         msg["Cc"] = cc_addresses

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/google_workspace_tools.py

@@ -24,8 +24,9 @@ from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
 from dhisana.schemas.sales import MessageItem
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.email_parse_helpers import *
+from dhisana.utils.email_body_utils import body_variants
 import asyncio
-from dhisana.schemas.common import (SendEmailContext, QueryEmailContext, ReplyEmailContext)
+from dhisana.schemas.common import (SendEmailContext, QueryEmailContext, ReplyEmailContext, BodyFormat)
 
 
 ################################################################################
@@ -161,15 +162,18 @@ async def send_email_using_service_account_async(
 
     gmail_api_url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send'
 
-    body = send_email_context.body or ""
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
 
-    if _looks_like_html(body):
+    if resolved_fmt == "text":
+        message = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
         # Gmail prefers multipart/alternative when HTML is present.
         message = MIMEMultipart("alternative")
-        message.attach(MIMEText(_html_to_plain_text(body), "plain", _charset="utf-8"))
-        message.attach(MIMEText(body, "html", _charset="utf-8"))
-    else:
-        message = MIMEText(body, _subtype="plain", _charset="utf-8")
+        message.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        message.attach(MIMEText(html_body, "html", _charset="utf-8"))
 
     message['to'] = send_email_context.recipient
     message['from'] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
@@ -509,6 +513,7 @@ class SendEmailContext(BaseModel):
     sender_name: str
     sender_email: str
     labels: Optional[List[str]]
+    body_format: BodyFormat = BodyFormat.AUTO
     
 @assistant_tool
 async def send_email_using_service_account_async(
@@ -537,8 +542,18 @@ async def send_email_using_service_account_async(
 
     gmail_api_url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send'
 
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+
     # Construct the MIME text message
-    message = MIMEText(send_email_context.body)
+    if resolved_fmt == "text":
+        message = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
+        message = MIMEMultipart("alternative")
+        message.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        message.attach(MIMEText(html_body, "html", _charset="utf-8"))
     message['to'] = send_email_context.recipient
     message['from'] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message['subject'] = send_email_context.subject
@@ -893,7 +908,16 @@ async def reply_to_email_async(
     message_id_header = headers_dict.get('Message-ID', '')
 
     # 3. Create the reply email message
-    msg = MIMEText(reply_email_context.reply_body)
+    plain_reply, html_reply, resolved_reply_fmt = body_variants(
+        reply_email_context.reply_body,
+        getattr(reply_email_context, "reply_body_format", None),
+    )
+    if resolved_reply_fmt == "text":
+        msg = MIMEText(plain_reply, _subtype="plain", _charset="utf-8")
+    else:
+        msg = MIMEMultipart("alternative")
+        msg.attach(MIMEText(plain_reply, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_reply, "html", _charset="utf-8"))
     msg['To'] = to_addresses
     if cc_addresses:
         msg['Cc'] = cc_addresses

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/mailgun_tools.py

@@ -7,6 +7,7 @@ import aiohttp
 
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.schemas.common import SendEmailContext
+from dhisana.utils.email_body_utils import body_variants
 
 
 def get_mailgun_notify_key(tool_config: Optional[List[Dict]] = None) -> str:
@@ -59,6 +60,7 @@ async def send_email_with_mailgun(
     subject: str,
     message: str,
     tool_config: Optional[List[Dict]] = None,
+    body_format: Optional[str] = None,
 ):
     """
     Send an email using the Mailgun API.
@@ -74,13 +76,17 @@ async def send_email_with_mailgun(
         api_key = get_mailgun_notify_key(tool_config)
         domain = get_mailgun_notify_domain(tool_config)
 
+        body = message or ""
         data = {
             "from": sender,
             "to": recipients,
             "subject": subject,
-            "html": message,
         }
 
+        plain_body, html_body, _ = body_variants(body, body_format)
+        data["text"] = plain_body
+        data["html"] = html_body
+
         async with aiohttp.ClientSession() as session:
             async with session.post(
                 f"https://api.mailgun.net/v3/{domain}/messages",
@@ -107,11 +113,17 @@ async def send_email_using_mailgun_async(
     api_key = get_mailgun_notify_key(tool_config)
     domain = get_mailgun_notify_domain(tool_config)
 
+    plain_body, html_body, _ = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+
     data = {
         "from": f"{send_email_context.sender_name} <{send_email_context.sender_email}>",
         "to": [send_email_context.recipient],
         "subject": send_email_context.subject,
-        "html": send_email_context.body or "",
+        "text": plain_body,
+        "html": html_body,
     }
 
     async with aiohttp.ClientSession() as session:

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/microsoft365_tools.py

@@ -12,6 +12,7 @@ from dhisana.schemas.common import (
     ReplyEmailContext,
 )
 from dhisana.schemas.sales import MessageItem
+from dhisana.utils.email_body_utils import body_variants
 
 
 def get_microsoft365_access_token(tool_config: Optional[List[Dict]] = None) -> str:
@@ -149,11 +150,18 @@ async def send_email_using_microsoft_graph_async(
     base_url = "https://graph.microsoft.com/v1.0"
     base_res = _base_resource(sender_email, tool_config, auth_mode)
 
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+    content_type = "Text" if resolved_fmt == "text" else "HTML"
+    content_body = plain_body if resolved_fmt == "text" else html_body
+
     message_payload: Dict[str, Any] = {
         "subject": send_email_context.subject,
         "body": {
-            "contentType": "HTML",
-            "content": send_email_context.body or "",
+            "contentType": content_type,
+            "content": content_body,
         },
         "toRecipients": [
             {"emailAddress": {"address": send_email_context.recipient}}

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/sendgrid_tools.py

@@ -14,6 +14,7 @@ import aiohttp
 
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.schemas.common import SendEmailContext
+from dhisana.utils.email_body_utils import body_variants
 
 # --------------------------------------------------------------------------- #
 # Mailgun (re-exported from dedicated module for backward compatibility)
@@ -57,6 +58,7 @@ async def send_email_with_sendgrid(
     subject: str,
     message: str,
     tool_config: Optional[List[Dict]] = None,
+    body_format: Optional[str] = None,
 ):
     """
     Send an email using SendGrid's v3 Mail Send API.
@@ -79,6 +81,12 @@ async def send_email_with_sendgrid(
     if not to_list:
         return {"error": "No recipients provided"}
 
+    plain_body, html_body, _ = body_variants(message, body_format)
+    content = [
+        {"type": "text/plain", "value": plain_body},
+        {"type": "text/html", "value": html_body},
+    ]
+
     payload = {
         "personalizations": [
             {
@@ -87,9 +95,7 @@ async def send_email_with_sendgrid(
             }
         ],
         "from": from_obj,
-        "content": [
-            {"type": "text/html", "value": message or ""}
-        ],
+        "content": content,
     }
 
     headers = {
@@ -126,11 +132,16 @@ async def send_email_using_sendgrid_async(
     Provider-style wrapper for SendGrid using SendEmailContext.
     Returns an opaque token since SendGrid does not return a message id.
     """
+    plain_body, html_body, _ = body_variants(
+        ctx.body,
+        getattr(ctx, "body_format", None),
+    )
     result = await send_email_with_sendgrid(
         sender=f"{ctx.sender_name} <{ctx.sender_email}>",
         recipients=[ctx.recipient],
         subject=ctx.subject,
         message=ctx.body or "",
+        body_format=getattr(ctx, "body_format", None),
         tool_config=tool_config,
     )
     # Normalise output to a string id-like value

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana/utils/smtp_email_tools.py

@@ -33,6 +33,7 @@ from dhisana.utils.google_workspace_tools import (
     QueryEmailContext,
     SendEmailContext,
 )
+from dhisana.utils.email_body_utils import body_variants
 
 
 # --------------------------------------------------------------------------- #
@@ -151,15 +152,18 @@ async def send_email_via_smtp_async(
     str
         The Message-ID of the sent message (e.g., "<uuid@yourdomain.com>").
     """
-    body = ctx.body or ""
+    plain_body, html_body, resolved_fmt = body_variants(
+        ctx.body,
+        getattr(ctx, "body_format", None),
+    )
 
-    if _looks_like_html(body):
+    if resolved_fmt == "text":
+        msg = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
         # Build multipart/alternative so HTML-capable clients see rich content.
         msg = MIMEMultipart("alternative")
-        msg.attach(MIMEText(_html_to_plain_text(body), "plain", _charset="utf-8"))
-        msg.attach(MIMEText(body, "html", _charset="utf-8"))
-    else:
-        msg = MIMEText(body, _subtype="plain", _charset="utf-8")
+        msg.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_body, "html", _charset="utf-8"))
 
     msg["From"] = f"{ctx.sender_name} <{ctx.sender_email}>"
     msg["To"] = ctx.recipient

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana.egg-info/PKG-INFO

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

{dhisana-0.0.1.dev227 → dhisana-0.0.1.dev228}/src/dhisana.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/dhisana/utils/compose_three_step_workflow.py
 src/dhisana/utils/composite_tools.py
 src/dhisana/utils/dataframe_tools.py
 src/dhisana/utils/domain_parser.py
+src/dhisana/utils/email_body_utils.py
 src/dhisana/utils/email_parse_helpers.py
 src/dhisana/utils/email_provider.py
 src/dhisana/utils/enrich_lead_information.py
@@ -105,6 +106,7 @@ tests/test_agent_tools.py
 tests/test_apollo_company_search.py
 tests/test_apollo_lead_search.py
 tests/test_connectivity.py
+tests/test_email_body_utils.py
 tests/test_google_document.py
 tests/test_hubspot_call_logs.py
 tests/test_linkedin_serper.py

dhisana-0.0.1.dev228/tests/test_email_body_utils.py

@@ -0,0 +1,23 @@
+import pytest
+
+from dhisana.schemas.common import BodyFormat
+from dhisana.utils.email_body_utils import body_variants
+
+
+@pytest.mark.parametrize(
+    "body,format_hint,expected_resolved",
+    [
+        ("<p>Hello</p>", BodyFormat.HTML, "html"),
+        ("Hello", BodyFormat.TEXT, "text"),
+    ],
+)
+def test_body_variants_honors_body_format_enum(body, format_hint, expected_resolved):
+    plain, html, resolved = body_variants(body, format_hint)
+
+    if expected_resolved == "html":
+        assert html == body
+        assert plain == "Hello"
+    else:
+        assert plain == body
+        assert html.startswith("<div")
+    assert resolved == expected_resolved