dhisana 0.0.1.dev279__tar.gz → 0.0.1.dev280__tar.gz

{dhisana-0.0.1.dev279 → dhisana-0.0.1.dev280}/PKG-INFO

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

{dhisana-0.0.1.dev279 → dhisana-0.0.1.dev280}/setup.py

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

{dhisana-0.0.1.dev279 → dhisana-0.0.1.dev280}/src/dhisana/schemas/common.py

@@ -389,13 +389,26 @@ class QueryEmailContext(BaseModel):
     labels: Optional[List[str]] = None
     
 
+class EmailRecipient(BaseModel):
+    email: str
+    name: Optional[str] = None
+
+
 class ReplyEmailContext(BaseModel):
+    """Context for replying to or forwarding an email."""
     message_id: str
     reply_body: str
     sender_email: str
-    sender_name: str
+    sender_name: Optional[str] = None
     headers: Optional[Dict[str, str]] = None
     fallback_recipient: Optional[str] = None
     mark_as_read: str = "True"
     add_labels: Optional[List[str]] = None
     reply_body_format: BodyFormat = BodyFormat.AUTO
+    to_recipients: Optional[List[EmailRecipient]] = None
+    cc_recipients: Optional[List[EmailRecipient]] = None
+    bcc_recipients: Optional[List[EmailRecipient]] = None
+    # Type of reply: "reply", "reply_all", or "forward". Defaults to "reply" if not specified.
+    reply_type: Optional[str] = None
+    # Custom subject line (primarily used for forward operations to override the default "Fwd: ..." prefix)
+    subject: Optional[str] = None

{dhisana-0.0.1.dev279 → dhisana-0.0.1.dev280}/src/dhisana/utils/google_oauth_tools.py

@@ -4,6 +4,7 @@ import logging
 import re
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
+from email.utils import getaddresses
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -78,6 +79,70 @@ def _rethrow_with_google_message(exc: httpx.HTTPStatusError, context: str) -> No
     )
 
 
+def _normalize_recipient(recipient: Any) -> Optional[Dict[str, str]]:
+    if recipient is None:
+        return None
+    if isinstance(recipient, dict):
+        email = recipient.get("email") or recipient.get("address")
+        name = recipient.get("name")
+    else:
+        email = getattr(recipient, "email", None) or getattr(recipient, "address", None)
+        name = getattr(recipient, "name", None)
+        if isinstance(recipient, str):
+            email = recipient
+            name = None
+    if not email:
+        return None
+    return {"email": email, "name": name}
+
+
+def _normalize_recipients(recipients: Optional[List[Any]]) -> List[Dict[str, str]]:
+    normalized: List[Dict[str, str]] = []
+    for recipient in recipients or []:
+        item = _normalize_recipient(recipient)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _parse_header_recipients(header_value: str) -> List[Dict[str, str]]:
+    parsed = getaddresses([header_value]) if header_value else []
+    return [{"email": address, "name": name} for name, address in parsed if address]
+
+
+def _dedupe_recipients(
+    recipients: List[Dict[str, str]],
+    exclude_emails: Optional[List[str]] = None,
+) -> List[Dict[str, str]]:
+    excluded = {email.lower() for email in (exclude_emails or []) if email}
+    seen: set[str] = set()
+    result: List[Dict[str, str]] = []
+    for recipient in recipients:
+        email = (recipient.get("email") or "").strip()
+        if not email:
+            continue
+        email_lc = email.lower()
+        if email_lc in seen or email_lc in excluded:
+            continue
+        seen.add(email_lc)
+        result.append({"email": email, "name": recipient.get("name")})
+    return result
+
+
+def _recipients_to_header(recipients: List[Dict[str, str]]) -> str:
+    parts: List[str] = []
+    for recipient in recipients:
+        name = recipient.get("name")
+        email = recipient.get("email")
+        if not email:
+            continue
+        if name:
+            parts.append(f"{name} <{email}>")
+        else:
+            parts.append(email)
+    return ", ".join(parts)
+
+
 def get_google_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     """
     Retrieve a Google OAuth2 access token from the 'google' integration config.
@@ -291,8 +356,6 @@ async def reply_to_email_google_oauth_async(
     headers_list = (original.get("payload") or {}).get("headers", [])
     # 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}"
     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 ""
@@ -300,31 +363,120 @@ async def reply_to_email_google_oauth_async(
     message_id_header = find_header(headers_list, "Message-ID") or ""
     thread_id = original.get("threadId")
 
+    reply_type = (reply_email_context.reply_type or "reply").lower()
+    if reply_type not in {"reply", "reply_all", "forward"}:
+        reply_type = "reply"
+
     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
+    explicit_to = _normalize_recipients(reply_email_context.to_recipients)
+    explicit_cc = _normalize_recipients(reply_email_context.cc_recipients)
+    explicit_bcc = _normalize_recipients(reply_email_context.bcc_recipients)
+
+    to_recipients: List[Dict[str, str]] = []
+    cc_recipients: List[Dict[str, str]] = []
+    bcc_recipients: List[Dict[str, str]] = []
+
+    if reply_type == "forward":
+        if not explicit_to:
+            raise ValueError("Forward requires explicit to_recipients.")
+        to_recipients = _dedupe_recipients(explicit_to)
+        cc_recipients = _dedupe_recipients(explicit_cc)
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+        if reply_email_context.subject:
+            subject = reply_email_context.subject
+        elif subject and not subject.lower().startswith("fwd:"):
+            subject = f"Fwd: {subject}"
+        else:
+            subject = subject or "Fwd:"
     else:
-        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
-        to_addresses = combined
-        cc_addresses = ""
+        if not subject.startswith("Re:"):
+            subject = f"Re: {subject}"
+
+        if reply_type == "reply_all":
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(from_header),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(reply_to_header),
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(to_header),
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to and reply_email_context.fallback_recipient:
+                base_to = _dedupe_recipients(
+                    [{"email": reply_email_context.fallback_recipient}],
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to:
+                raise ValueError(
+                    "No valid recipient found in the original message; refusing to reply to sender."
+                )
+            base_to_emails = [recipient.get("email") for recipient in base_to if recipient.get("email")]
+            base_cc_candidates = _parse_header_recipients(to_header) + _parse_header_recipients(cc_header)
+            base_cc = _dedupe_recipients(
+                base_cc_candidates,
+                exclude_emails=[reply_email_context.sender_email] + base_to_emails,
+            )
+        else:
+            cc_header_value = 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_header_value = reply_to_header
+            elif from_header and not _is_self(from_header):
+                to_header_value = from_header
+            elif to_header and not _is_self(to_header):
+                to_header_value = to_header
+            else:
+                to_header_value = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+                cc_header_value = ""
+
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(to_header_value),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+            base_cc = _dedupe_recipients(
+                _parse_header_recipients(cc_header_value),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+
+            if not base_to and reply_email_context.fallback_recipient and not _is_self(reply_email_context.fallback_recipient):
+                base_to = _dedupe_recipients([{"email": reply_email_context.fallback_recipient}])
+                base_cc = []
+
+            if not base_to:
+                raise ValueError(
+                    "No valid recipient found in the original message; refusing to reply to sender."
+                )
+
+        to_recipients = base_to
+        if explicit_to:
+            to_recipients = _dedupe_recipients(explicit_to)
+
+        cc_recipients = base_cc
+        if explicit_cc:
+            cc_recipients = _dedupe_recipients(
+                base_cc + explicit_cc,
+                exclude_emails=[recipient.get("email") for recipient in to_recipients if recipient.get("email")],
+            )
+
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
 
-    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 = ""
+    to_addresses = _recipients_to_header(to_recipients)
+    cc_addresses = _recipients_to_header(cc_recipients)
+    bcc_addresses = _recipients_to_header(bcc_recipients)
 
-    if not to_addresses or _is_self(to_addresses):
+    if not to_addresses:
         raise ValueError(
             "No valid recipient found in the original message; refusing to reply to sender."
         )
@@ -344,15 +496,18 @@ async def reply_to_email_google_oauth_async(
     msg["To"] = to_addresses
     if cc_addresses:
         msg["Cc"] = cc_addresses
-    msg["From"] = f"{reply_email_context.sender_name} <{reply_email_context.sender_email}>"
+    if bcc_addresses:
+        msg["Bcc"] = bcc_addresses
+    sender_display = reply_email_context.sender_name or reply_email_context.sender_email
+    msg["From"] = f"{sender_display} <{reply_email_context.sender_email}>"
     msg["Subject"] = subject
-    if message_id_header:
+    if reply_type != "forward" and message_id_header:
         msg["In-Reply-To"] = message_id_header
         msg["References"] = message_id_header
 
     raw_message = base64.urlsafe_b64encode(msg.as_bytes()).decode()
     payload = {"raw": raw_message}
-    if thread_id:
+    if thread_id and reply_type != "forward":
         payload["threadId"] = thread_id
 
     # 3) Send the reply
@@ -391,6 +546,8 @@ async def reply_to_email_google_oauth_async(
         "email_subject": subject,
         "email_sender": reply_email_context.sender_email,
         "email_recipients": [to_addresses] + ([cc_addresses] if cc_addresses else []),
+        "to_recipients": to_recipients,
+        "cc_recipients": cc_recipients,
         "read_email_status": "READ" if str(reply_email_context.mark_as_read).lower() == "true" else "UNREAD",
         "email_labels": sent.get("labelIds", []),
     }

{dhisana-0.0.1.dev279 → dhisana-0.0.1.dev280}/src/dhisana/utils/google_workspace_tools.py

@@ -10,6 +10,7 @@ import re
 import uuid
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
+from email.utils import getaddresses
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -33,6 +34,69 @@ from dhisana.schemas.common import (SendEmailContext, QueryEmailContext, ReplyEm
 #                               HELPER FUNCTIONS
 ################################################################################
 
+def _normalize_recipient(recipient: Any) -> Optional[Dict[str, str]]:
+    if recipient is None:
+        return None
+    if isinstance(recipient, dict):
+        email = recipient.get("email") or recipient.get("address")
+        name = recipient.get("name")
+    else:
+        email = getattr(recipient, "email", None) or getattr(recipient, "address", None)
+        name = getattr(recipient, "name", None)
+        if isinstance(recipient, str):
+            email = recipient
+            name = None
+    if not email:
+        return None
+    return {"email": email, "name": name}
+
+
+def _normalize_recipients(recipients: Optional[List[Any]]) -> List[Dict[str, str]]:
+    normalized: List[Dict[str, str]] = []
+    for recipient in recipients or []:
+        item = _normalize_recipient(recipient)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _parse_header_recipients(header_value: str) -> List[Dict[str, str]]:
+    parsed = getaddresses([header_value]) if header_value else []
+    return [{"email": address, "name": name} for name, address in parsed if address]
+
+
+def _dedupe_recipients(
+    recipients: List[Dict[str, str]],
+    exclude_emails: Optional[List[str]] = None,
+) -> List[Dict[str, str]]:
+    excluded = {email.lower() for email in (exclude_emails or []) if email}
+    seen: set[str] = set()
+    result: List[Dict[str, str]] = []
+    for recipient in recipients:
+        email = (recipient.get("email") or "").strip()
+        if not email:
+            continue
+        email_lc = email.lower()
+        if email_lc in seen or email_lc in excluded:
+            continue
+        seen.add(email_lc)
+        result.append({"email": email, "name": recipient.get("name")})
+    return result
+
+
+def _recipients_to_header(recipients: List[Dict[str, str]]) -> str:
+    parts: List[str] = []
+    for recipient in recipients:
+        name = recipient.get("name")
+        email = recipient.get("email")
+        if not email:
+            continue
+        if name:
+            parts.append(f"{name} <{email}>")
+        else:
+            parts.append(email)
+    return ", ".join(parts)
+
 def get_google_workspace_token(tool_config: Optional[List[Dict]] = None) -> Any:
     """
     Retrieves the GOOGLE_SERVICE_KEY (base64-encoded JSON) from the provided tool configuration or environment.
@@ -945,8 +1009,6 @@ async def reply_to_email_async(
     headers_list = original_message.get('payload', {}).get('headers', [])
     # 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 ''
@@ -954,29 +1016,118 @@ async def reply_to_email_async(
     message_id_header = find_header(headers_list, 'Message-ID') or ''
     thread_id = original_message.get('threadId')
 
+    reply_type = (reply_email_context.reply_type or "reply").lower()
+    if reply_type not in {"reply", "reply_all", "forward"}:
+        reply_type = "reply"
+
     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 ''
-    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
+    explicit_to = _normalize_recipients(reply_email_context.to_recipients)
+    explicit_cc = _normalize_recipients(reply_email_context.cc_recipients)
+    explicit_bcc = _normalize_recipients(reply_email_context.bcc_recipients)
+
+    to_recipients: List[Dict[str, str]] = []
+    cc_recipients: List[Dict[str, str]] = []
+    bcc_recipients: List[Dict[str, str]] = []
+
+    if reply_type == "forward":
+        if not explicit_to:
+            raise ValueError("Forward requires explicit to_recipients.")
+        to_recipients = _dedupe_recipients(explicit_to)
+        cc_recipients = _dedupe_recipients(explicit_cc)
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+        if reply_email_context.subject:
+            subject = reply_email_context.subject
+        elif subject and not subject.lower().startswith("fwd:"):
+            subject = f"Fwd: {subject}"
+        else:
+            subject = subject or "Fwd:"
     else:
-        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
-        to_addresses = combined
-        cc_addresses = ''
+        if not subject.startswith('Re:'):
+            subject = f'Re: {subject}'
 
-    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 reply_type == "reply_all":
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(from_header),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(reply_to_header),
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(to_header),
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to and reply_email_context.fallback_recipient:
+                base_to = _dedupe_recipients(
+                    [{"email": reply_email_context.fallback_recipient}],
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+            if not base_to:
+                raise ValueError(
+                    "No valid recipient found in the original message; refusing to reply to sender."
+                )
+            base_to_emails = [recipient.get("email") for recipient in base_to if recipient.get("email")]
+            base_cc_candidates = _parse_header_recipients(to_header) + _parse_header_recipients(cc_header)
+            base_cc = _dedupe_recipients(
+                base_cc_candidates,
+                exclude_emails=[reply_email_context.sender_email] + base_to_emails,
+            )
+        else:
+            cc_header_value = cc_header or ''
+            if reply_to_header and not _is_self(reply_to_header):
+                to_header_value = reply_to_header
+            elif from_header and not _is_self(from_header):
+                to_header_value = from_header
+            elif to_header and not _is_self(to_header):
+                to_header_value = to_header
+            else:
+                to_header_value = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+                cc_header_value = ''
+
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(to_header_value),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+            base_cc = _dedupe_recipients(
+                _parse_header_recipients(cc_header_value),
+                exclude_emails=[reply_email_context.sender_email],
+            )
+
+            if not base_to and reply_email_context.fallback_recipient and not _is_self(reply_email_context.fallback_recipient):
+                base_to = _dedupe_recipients([{"email": reply_email_context.fallback_recipient}])
+                base_cc = []
+
+            if not base_to:
+                raise ValueError(
+                    "No valid recipient found in the original message; refusing to reply to sender."
+                )
 
-    if not to_addresses or _is_self(to_addresses):
+        to_recipients = base_to
+        if explicit_to:
+            to_recipients = _dedupe_recipients(explicit_to)
+
+        cc_recipients = base_cc
+        if explicit_cc:
+            cc_recipients = _dedupe_recipients(
+                base_cc + explicit_cc,
+                exclude_emails=[recipient.get("email") for recipient in to_recipients if recipient.get("email")],
+            )
+
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+    to_addresses = _recipients_to_header(to_recipients)
+    cc_addresses = _recipients_to_header(cc_recipients)
+    bcc_addresses = _recipients_to_header(bcc_recipients)
+
+    if not to_addresses:
         raise ValueError(
             "No valid recipient found in the original message; refusing to reply to sender."
         )
@@ -995,16 +1146,19 @@ async def reply_to_email_async(
     msg['To'] = to_addresses
     if cc_addresses:
         msg['Cc'] = cc_addresses
-    msg['From'] = f"{reply_email_context.sender_name} <{reply_email_context.sender_email}>"
+    if bcc_addresses:
+        msg['Bcc'] = bcc_addresses
+    sender_display = reply_email_context.sender_name or reply_email_context.sender_email
+    msg['From'] = f"{sender_display} <{reply_email_context.sender_email}>"
     msg['Subject'] = subject
-    msg['In-Reply-To'] = message_id_header
-    msg['References'] = message_id_header
+    if reply_type != "forward":
+        msg['In-Reply-To'] = message_id_header
+        msg['References'] = message_id_header
 
     raw_message = base64.urlsafe_b64encode(msg.as_bytes()).decode()
-    payload = {
-        'raw': raw_message,
-        'threadId': thread_id
-    }
+    payload = {'raw': raw_message}
+    if thread_id and reply_type != "forward":
+        payload['threadId'] = thread_id
 
     # 4. Send the reply
     send_message_url = f'{gmail_api_base_url}/messages/send'
@@ -1014,7 +1168,7 @@ async def reply_to_email_async(
         sent_message = response.json()
 
     # 5. (Optional) Mark the thread as read
-    if reply_email_context.mark_as_read.lower() == "true":
+    if str(reply_email_context.mark_as_read).lower() == "true":
         modify_thread_url = f'{gmail_api_base_url}/threads/{thread_id}/modify'
         modify_payload = {'removeLabelIds': ['UNREAD']}
         async with httpx.AsyncClient() as client:
@@ -1036,7 +1190,9 @@ async def reply_to_email_async(
         "email_subject": subject,
         "email_sender": reply_email_context.sender_email,
         "email_recipients": [to_addresses] + ([cc_addresses] if cc_addresses else []),
-        "read_email_status": 'READ' if reply_email_context.mark_as_read.lower() == "true" else 'UNREAD',
+        "to_recipients": to_recipients,
+        "cc_recipients": cc_recipients,
+        "read_email_status": 'READ' if str(reply_email_context.mark_as_read).lower() == "true" else 'UNREAD',
         "email_labels": sent_message.get('labelIds', [])
     }